在以前的博客中提到的一个服务端，在以前压力测试的过程中，发现单核CPU最多能达到1000TPS
还以为是服务端性能不够好，所以一直想着怎么去优化它。
但优化的思路明显不多，所以就考虑换一种压力测试的方法，事实证明这个想法是对的。
以前的压力测试方法 ：
for((i=;i<$;i++));do
for((j=;j<$;j++));do
cmd="./client $1 $2 4 $a $a $a $a"
echo `time $cmd`
done&
done
思路是用多进程来实现并发，代码如上所示；
现在的压力测试方法：
//客户端程序 /******* 客户端程序 client.c ************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netdb.h>
#include <netinet/in.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/epoll.h> static struct sockaddr_in server_addr;
static int epoll_fd;
static int currency,total_req,total_read;
static struct epoll_event* events; int setnonblock(int fd)
{
int flags;
flags = fcntl(fd, F_GETFL);
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags);
} void new_conn()
{
if(--total_req < )return;
int sockfd;
/* 客户程序开始建立 sockfd描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,))==-)
{
fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));
return ;
}
setnonblock(sockfd); //让epoll接管
struct epoll_event event;
event.data.fd=sockfd;
event.events = EPOLLOUT|EPOLLIN;
epoll_ctl(epoll_fd,EPOLL_CTL_ADD, sockfd,&event); /* 客户程序发起连接请求 */
if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-)
{
if(errno == EINPROGRESS)
return;
fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));
return;
} }
int main(int argc, char *argv[])
{
struct hostent *host;
if((host=gethostbyname(argv[]))==NULL)
{
fprintf(stderr,"Gethostname error\n");
exit();
} int portnumber;
if((portnumber=atoi(argv[]))<)
{
fprintf(stderr,"Usage:%s hostname portnumber\a\n",argv[]);
exit();
} /* 客户程序填充服务端的资料 */
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family=AF_INET;
server_addr.sin_port=htons(portnumber);
server_addr.sin_addr=*((struct in_addr *)host->h_addr); //并发数和总的请求数
currency = atoi(argv[]);
total_req = total_read = currency * atoi(argv[]); if((epoll_fd=epoll_create())==-)
{
fprintf(stderr,"epoll create Error:%s\a\n",strerror(errno));
exit();
} events = calloc(,sizeof(struct epoll_event)); //初始化并发数个连接
int i;
for(i=;i<currency;i++)new_conn(); while()
{
fprintf(stderr,"while\n");
int n,j;
n = epoll_wait(epoll_fd, events, , -);
for(j=;j<n;j++)
{
if(events[j].events & EPOLLOUT)
{
fprintf(stderr, "can write\n",n);
int fd = events[j].data.fd;
int optval;
socklen_t optlen = sizeof(optval);
if(getsockopt(fd,SOL_SOCKET,SO_ERROR,&optval, &optlen) == -)
{
fprintf(stderr, "getsockopt error\n",n);
} else if(optval != ) {
fprintf(stderr, "connect error\n",n);
continue;
};
struct epoll_event event;
event.data.fd=fd;
event.events = EPOLLIN;
epoll_ctl(epoll_fd,EPOLL_CTL_MOD, fd,&event); char buffer2[];
memset(buffer2,,);
int type,score,time;
unsigned long oid;
type= htonl(atoi(argv[]));
oid= htonl(atol(argv[]));
score= htonl(atoi(argv[]));
char*pass="220106aa";
char*loc = buffer2;
memcpy((void*)loc,(void*)(pass),);
loc+=;
memcpy((void*)loc,(void*)(&type),);
loc+=;
memcpy((void*)loc,(void*)(&oid),);
loc+=;
memcpy((void*)loc,(void*)(&score),);
write(fd, buffer2, );
/* 连接成功了 */
}
else if(events[j].events & EPOLLIN)
{
fprintf(stderr, "can read\n",n);
int fd = events[j].data.fd;
char buf[];
int n=read(fd,buf,);
close(fd);
new_conn();
if(n==-)
{
fprintf(stderr,"read Error:%s\a\n",strerror(errno));
continue;
}
buf[n]=;
fprintf(stderr, "return %s\n",buf);
fprintf(stderr, "total_read %d\n",total_read);
if (--total_read <= )return;
}
}
}
}
思路就是用单进程来测试，用EPOOL来实现并发
代码也可下载：
百度网盘：http://pan.baidu.com/s/1vdQqB
github : https://github.com/hxdoit/real_time_rank/blob/master/server1-1.0/epoll.c
性能对比：
环境：单核CPU，两台机器，一台服务端，一台客户端
多进程：690TPS
EPOLL：6435TPS
性能提高了十倍！
分析：
在单个机器上，使用多进程，资源消耗很大，不可能达到太大的并发
而使用EPOLL，单进程同时监听多个socket，可以达到较高并发