1.有关本文档
       本文档所有分析都是在1.2版本的上,偶尔会提到比较1.1版本.其他版本没有阅读.
        个星期时间LINUX中使用是epoll,监听EPOLLIT水平触发.因此从理论上讲,memcache并发连接可以达到infinite,前提是event池和内存空间足够大.而没有和linux线程处理有关系.事实上,在后面测试中便可发现,在单结点连接压力测试时,瞬时并发连接可以达到5000多个.只是等待触发时间上长短和有效无效区别.
       在表4.2中可以清晰看到并发连接些数据.
       3.  服务端系统负载
       通过自己编写服务器端,对单结点memcache进行了连接压力测试.其中测试用例编写是这样:启用 7个客户端,每个客户端串行运行1000个进程,每个进程开3000线程,每个线程执行10次memcache读操作或者写操作(操作相同).客户端并发连接.
       1.  客户端(7)环境:Intel(R) Xeon(R) CPU 5120 @ 1.86GHz,4G memory.
       2.  服务器端(1)环境:Intel(R) Xeon(R) CPU 5120 @ 1.86GHz,4G memory.
       3.  网络环境:100M网卡,Cisco交换机.
       4.  数据记录:见表4.2和图4.2.
=insertimage title=点击在新窗口中浏览此图片 height=513 alt=点击在新窗口中浏览此图片 src="http://www.crazycoder.cn/WebFiles/20091/05b9efc3-e38a-4e9d-99db-f0df2806847c.jpg" width=573 border=0>
表4.2 memcache连接和系统负载
图4.2 memcache连接和系统负载
       很显然,memcache运行在系统cpu消耗上占十分少比重,即便是很恐怖并发连接也不会给系统带来多大负载,其磁盘IO free(所有操作都在内存中)和相应内存分配机制决定其占用cpu极少,而相反,在网络IO上却花费很大时间.
       4.  空间分配,命中率
       由于本地测试式get数据非常固定,因此命中率基本为100%.在10.68.1.31上运行了个有前端应用memcachce服务器,运行时间已经有364个多小时了.
       因此通过10.68.1.31上数据介绍说明(版本为1.1.13).通过memcache统计协议可以清楚看到其命中率高达95.9%,如表4.3所示:
=insertimage title=点击在新窗口中浏览此图片 alt=点击在新窗口中浏览此图片 src="http://www.crazycoder.cn/WebFiles/20091/65e0dbd9-cc0b-40a7-a010-de899d19a366.jpg" border=0>
表4.3 memcache空间分配和命中

5.memcache客户端编写
       1.  memcache协议
       在memcache协议中规定了Client和Server通信规则.
       在源码分析中,主要分析了update/get/del/incr/decr几类处理过程.其具体规则可以在官方文档中有介绍说明,这里做简单解释.
引用
1．  Update(/add/replace):
Client请求规则:
\r\n
\r\n
Server响应规则:
STORED\r\n 或者 NOT_STORED\r\n

其中是,add,replace 3种中种;
是client请求存储键值;
是任意16bit长unsigned 值,在get操作时,也将伴随data起返回,可以用来存储某些认证信息或者描述信息;
是key－value对象消亡时间,如果为0,则代表永不消亡;
是数据长度,千万小心,这个很重要,在memcache源代码里,直接读取这个数值来当作数据长度,而不是用strlen计算.这个显而易见,数据中有可能存在/r/n符号,也就是协议中规定分隔符.如果出现,则严格按长度取数据;
也就是value值,可以包含\r\n值.

STORED代表update操作成功NOT_STORED代表update操作失败.

2．  Get(get/bget)
Client请求规则:
*\r\n
Server响应规则:
VALUE\r\n
\r\n
END\r\n

Get/bget操作可以次操作多个key值,server响应格式中关键字可以参看上面解释,END代表数据显示结束.如果没有数据,则只有个END\r\n.

3．  Delete(delete)
Client请求规则:
delete\r\n
Server响应规则:
DELETED\r\n 或者 NOT_DELETED\r\n

其中是真正删除从server端删除时间(sec),在时间未到前,server只将其放入个delete队列里,其他诸如add/replace/get操作不能成功.

4．  Incr/decr(incr/decr)
Client请求规则:
\r\n
Server响应规则:
   NOT_FOUND\r\n 或者\r\n

   其中,client请求是将要在对应value上增减值;
   Server是增减后新值.

5．  其他(如stats/quit等)
可以去看协议原文,使用不是太多.



       2.  针对协议个简单实现
       在这个例子中简单实现了个能进行update/get/delete操作测试用例,只是简单应用而已.如果可以,模仿这个写个简单客户端应该难度不大.
引用
/****************************************\
*            mem_benchmark_conn2.c
*
*  Mon Mar 7 10:52:30 2007
*  Copyright  2007  Spark Zheng
*  Mail
*  v0.1 Mar 5 2007 file:mem_benchmark_conn.c
\****************************************/

# < stdio.h>
# < stdlib.h>
# < .h>
# < ctype.h>

# < unistd.h>
# < pthread.h>
# < time.h>
# < sys/types.h>
# < sys/time.h>
# < sys/resource.h>
//# < sys/.h>
//# < netdb.h>
//# < arpa/inet.h>

#ndef MEM_SERVER
# MEM_SERVER "10.210.71.25"
#end

#ndef MEM_PORT
# MEM_PORT 11211
#end

void p_usage(void);
void *conn_mem(void);
NonbSocket(const char *server, port);
mem_( sock,const char *key,const char *value);
mem_add( sock,const char *key,const char *value);
mem_get( sock,const char *key,char *value);
mem_del( sock,const char *key);

( argc,char **argv){
        conn=0;
        i=0;
       pthread_t ptid[10000];
       struct rlimit rlim;
       struct timeval tv1,tv2;

       (argc < 2){
               p_usage;
               exit(255);
       }

       conn = atoi(argv[1]);

       (getrlimit(RLIMIT_NOFILE,&rlim) != 0){
               fprf(stderr,"getrlimit error in line %d\n",__LINE__);
               exit(254);
       }

       ((conn > rlim.rlim_cur) && (2*conn > 1024)){
               rlim.rlim_cur = 2*conn;
       }
       (rlim.rlim_cur > rlim.rlim_max){
               rlim.rlim_max = rlim.rlim_cur;
       }

       (rlimit(RLIMIT_NOFILE,&rlim) != 0){
               fprf(stderr,"rlimit error in line %d\n",__LINE__);
               exit(254);
       }

       gettimeofday(&tv1,NULL);

       while(i < conn){
          (pthread_create(&ptid[i],NULL,(void *)conn_mem,NULL) != 0){
                perror("pthread_create error\n");
                exit(253);
          }
       }
       i=0;

       while(i < conn){
          (pthread_join(ptid[i],NULL) != 0){
                perror("pthread_join error\n");
                exit(253);
          }
       }

       gettimeofday(&tv2,NULL);

       prf("time is %f,conn is %f persecond\n",((tv2.tv_sec-tv1.tv_sec)+(tv2.tv_usec-tv1.tv_usec)/1000000.0),conn/((tv2.tv_sec-tv1.tv_sec)+(tv2.tv_usec-tv1.tv_usec)/1000000.0));
        0;
}

void p_usage(void){
       prf("Usage:./mem_benchmark_conn < conn_num >\n");
       prf("Notice: the conn_num must <= 10000\n");
       ;
}

void *conn_mem(void){
        sock;
       char *key = "test_a";
       char *value = "this is a";

       ((sock=NonbSocket(MEM_SERVER,MEM_PORT)) < 0){
               fprf(stderr," error in line %d\n",__LINE__);
                NULL;
       }

i=0;
while(i < 10){
///*
       mem_(sock,key,value);
//*/
/*
       char *key2="test_b";
       char *value2="this is b";
       mem_add(sock,key2,value2);
*/
/*
       char buf[101];
       mem_get(sock,key,buf);
       prf("get value for %s is %s\n",key,buf);
*/
/*
       char *key3="test_c";
       mem_del(sock,key);
*/
}
       close(sock);
        NULL;
}

mem_( sock,const char *key,const char *value){
       char [101];
       char recv_buf[101];
       sprf(," %s 0 0 %d\r\n%s\r\n",key,strlen(value),value);
       (write(sock,,strlen()) < 0){
               fprf(stderr,"write error in line %d\n",__LINE__);
                -1;
       }

       (read(sock,recv_buf,100) < 0){
               fprf(stderr,"read error in line %d\n",__LINE__);
                -2;
       }

       prf("in %s\n",recv_buf);
        0;
}

mem_add( sock,const char *key,const char *value){
       char add[101];
       char recv_buf[101];
       sprf(add,"add %s 0 0 %d\r\n%s\r\n",key,strlen(value),value);
       (write(sock,add,strlen(add)) < 0){
               fprf(stderr,"write error in line %d\n",__LINE__);
                -1;
       }
       (read(sock,recv_buf,100) < 0){
               fprf(stderr,"read error in line %d\n",__LINE__);
                -2;
       }

       prf("in add %s\n",recv_buf);
        0;
}

mem_get( sock,const char *key,char *value){
       char get[101];
       char recv_buf[101];
       sprf(get,"get %s\r\n",key);
       (write(sock,get,strlen(get)) < 0){
               fprf(stderr,"write error in line %d\n",__LINE__);
                -1;
       }

       (read(sock,recv_buf,100) < 0){
               fprf(stderr,"read error in line %d\n",__LINE__);
                -2;
       }
       strncpy(value,recv_buf,strlen(recv_buf));
       prf("in get %s\n",recv_buf);
        0;
}

mem_del( sock,const char *key){
       char del[101];
       char recv_buf[101];
       sprf(del,"delete %s 0\r\n",key);
       (write(sock,del,strlen(del)) < 0){
               fprf(stderr,"write error in line %d\n",__LINE__);
                -1;
       }
       (read(sock,recv_buf,100) < 0){
               fprf(stderr,"read error in line %d\n",__LINE__);
                -2;
       }

       prf("in del %s\n",recv_buf);
        0;
}


       3.  分布式实现
       分布式实现可以这么完成,构建个struct用于存放server信息.对于每个请求key值,用很简单hash算法(如libmemcache用是crc32)映射到server中某个,然后对其进行通信.获取处理结果的后,将结果美化返回client.

6.libevent介绍
       1.  libevent
       libevent是个事件触发网络库,适用于windows,linux,bsd等多种平台,内部使用iopc/epoll/kqueue等系统管理事件机制,而且根据libevent官方网站WebSite上公布数据统计,似乎也有着非凡性能.
       从代码中看,libevent支持用户使用 3种类型事件,分别是网络IO,定时器,信号 3种,在定时器实现上使用了红黑树(RB tree)数据结构,以达到高效查找,排序,删除定时器目,网络IO上,libeventepoll居然用EPOLLLT水平触发方式,不容易出错,但是在效率上可能比EPOLLET要低些.跟网络无关,libevent也有些缓冲区管理,libevent没有提供缓存Cache.而且libevent接口形式非常值得参考.
       2.  epoll
在linux中,libevent用是epoll.如果有兴趣话,可以查看man epoll页面.或者看前面blog上引用libevent资源.
       
       文章学习了黑夜路人相关文章,奶瓶博士memcache深度分析文章和些memcache作者文章,在此向他们致敬.