1. poll
poll也是一种多路转接的方案，解决了select的fd有上限和每次调用都要重新设置关心的fd的问题。
2. poll接口
#include
int poll(struct pollfd* fds, nfds_t nfds, int timeout);
参数：fds：可以看成是动态数组/数组/结构体数组
nfds：数组类长度
timeout：单位ms(毫秒) >0:在timeout内阻塞，否则非阻塞
=0：非阻塞等待
<0：阻塞等待
返回值：同select
poll的作用和select一模一样：只负责等待
struct pollfd{
int fd; //文件描述符 用户->内核：要帮我关心一下fd
short events; //等待的事件 用户->内核：关心fd上的事件
short revents; //实际发生的事件 内核->用户：要关心的fd上面的events中，有哪些事件就绪了
};输入时看：fd+events
输出时看：fd+revents
poll将输入输出进行了分离，使得不需要对参数进行重新设定
poll中的events和revents的取值：
pollfd这个数组可以由程序员自己决定，解决了selectfd有上限的问题。
3. poll代码实现
poll的代码基于前一篇文章的的select修改得来的，只修改了selectserver.hpp：
pollserver.hpp:
#pragma once
#include <string>
#include <iostream>
#include <functional>
#include "sock.hpp"
#include "log.hpp"
#include "err.hpp"
namespace poll_ns
{
static const int defaultport = 8080;
static const int num = 2048;
static const int defaultfd = -1;
using func_t = std::function<std::string (const std::string&)>;
class PollServer
{
public:
PollServer(func_t func, int port = defaultport)
: _port(port), _listenSock(-1), _func(func), _rfds(nullptr)
{
}
void initServer()
{
_listenSock = Sock::Socket();
Sock::Bind(_listenSock, _port);
Sock::Listen(_listenSock);
// logMessage(NORMAL, "creat socket..");
_rfds = new struct pollfd[num];
for (int i = 0; i < num; i++) ResetItem(i);
_rfds[0].fd = _listenSock; // 不变了
_rfds[0].events = POLLIN;
}
void Print()
{
std::cout << "fd list: ";
for (int i = 0; i < num; i++)
{
if (_rfds[i].fd != defaultfd)
std::cout << _rfds[i].fd << " ";
}
std::cout << std::endl;
}
void ResetItem(int i)
{
_rfds[i].fd = defaultfd;
_rfds[i].events = 0;
_rfds[i].revents = 0;
}
void Accepter(int listenSock)
{
// 走到这里accept不会阻塞 listensock套接字已经就绪了
string clientIp;
uint16_t clientPort = 0;
int sock = Sock::Accept(listenSock, &clientIp, &clientPort);
if (sock < 0)
return;
logMessage(NORMAL, "accept success [%s:%d]", clientIp.c_str(), clientPort);
// sock 我们能直接recv/read吗？--不能 整个代码 只有select有资格检测事件是否就绪
// 将新的sock交给select
// 将新的sock托管给select的本质，将sock添加到_fdArray数组中
int i;
for (i = 0; i < num; i++)
{
if (_rfds[i].fd != defaultfd)
continue;
else
break;
}
if (i == num)
{
logMessage(WARNING, "server is full, please wait!");
close(sock);
}
else
{
_rfds[i] .fd= sock; // 将新创建的sock设置到rfds中
_rfds[i].events = POLLIN;
_rfds[i].revents = 0;
}
Print();
}
void Recver(int pos)
{
// 1.读取
// 这样读取有问题！不能保证是否读取到一个完整的报文
char buffer[1024];
ssize_t s = recv(_rfds[pos].fd, buffer, sizeof(buffer) - 1, 0); // 这里在进行recv'时，不会被阻塞，因为走到这里时文件描述符已经就绪了
if (s > 0)
{
buffer[s] = 0;
logMessage(NORMAL, "client# %s", buffer);
}
else if (s == 0)
{
close(_rfds[pos].fd);
ResetItem(pos);
logMessage(NORMAL, "client quit");
return;
}
else
{
close(_rfds[pos].fd);
ResetItem(pos);
logMessage(ERROR, "client quit: %s", strerror(errno));
return;
}
// 2.处理request
std::string response = _func(buffer);
// 3.返回response
// write
write(_rfds[pos].fd, response.c_str(), response.size());
}
// handler event 中 不仅仅是有一个fd就绪，可能有多个
// 我们的select只处理了read
void HandlerReadEvent()
{
for (int i = 0; i < num; i++)
{
// 过滤掉非法的fd
if (_rfds[i].fd == defaultfd)
continue;
if(!(_rfds[i].revents & POLLIN)) continue;
// 下面的为正常的fd
// 正常的fd不一定就绪
// 目前一定是listen套接字
if (_rfds[i].fd == _listenSock && (_rfds[i].revents & POLLIN))
Accepter(_listenSock);
else if(_rfds[i].revents & POLLIN)
Recver(i);
else
{
}
}
}
void start()
{
int timeout = -1;
for (;;)
{
int n = poll(_rfds, num, timeout);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "poll error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
// 说明有时间就绪了，目前只有一个监听事件就绪
logMessage(NORMAL, "get a new link...");
HandlerReadEvent();
break;
}
}
}
~PollServer()
{
if (_listenSock < 0)
close(_listenSock);
if (_rfds)
delete[] _rfds;
}
private:
int _port;
int _listenSock;
struct pollfd* _rfds;
func_t _func;
};
}得到了与select相同的实验结果，并且结局了select的两个缺点：
poll的缺点主要是遍历的问题：
poll中监听的文件描述符数目增多时 和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符. 次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中. 同时连接的大量客户端在一时刻可能只有很少的处于就绪状态, 因此随着监视的描述符数量的增长, 其效率也会线性下降.
4. epoll
它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法.
5. epoll接口
#include <sys/epoll.h>
int epoll_create(int size); -- 创建一个epoll模型，size>0
返回值：成功则返回一个文件描述符，失败返回-1
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event);参数：epfd：为epoll_create的返回值
op：增、改、删：fd对应的事件的类型 EPOLL_CTL_ADD、EPOLL_CTL_MOD、EPOLL_CTL_DEL
fd：用户告诉内核：你要帮我关心fd上的event事件
typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;//保存触发事件的某个文件描述符相关的数据
struct epoll_event {
__uint32_t events; /* epoll event */
epoll_data_t data; /* User data variable */
};其中events表示感兴趣的事件和被触发的事件，可能的取值为：
EPOLLIN：表示对应的文件描述符可以读；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数可读；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： ET的epoll工作模式；
int eoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
返回值：>0：有几个fd就绪 ==0：超时返回 <0：调用失败
参数：epfd：epoll_create的返回值
events：输出型参数，数组，内核告诉用户：哪些关心的fd事件就绪
maxevents：events的最大容量
timeout：>0: ms ==0：非阻塞等待 <0: 阻塞等待
6. epoll底层原理
红黑树的节点表示：用户告诉内核，哪些sock上的哪些events需要OS关心
还有一个就绪队列，双向链表，每个节点表示：内核告诉用户，哪些sock上的events已经就绪了
就绪的过程就相当于是从红黑树节点转移到就绪队列节点的过程，两种数据结构使用的是同一个节点，只需更该指针即可
每一个节点对应的是一个fd，底层有对应的struct file对象，其中有一个void* private_data字段，指向一个回调函数，这个回调函数的作用就是转移节点的，从而不需要遍历树来确定某个fd对应的事件是否就绪。
epoll模型：
epoll_create：创建epoll模型
epoll_ctl：向红黑树中增、删、改
epoll_wait：找到对应的epoll莫i选哪个，拿到就绪队列中的就绪事件(就绪队列中的事件已经就绪了)；不需要遍历检测(检测事件就绪)，只需要遍历拷贝
epoll_wait将所有就绪的事件按照顺序放入用户传入的数组中，有几个就绪事件则返回几。就绪队列中数据很多时，一次拿不完也没事(队列先进先出)。epoll不需要自己维护辅助数组，换为了OS维护的红黑树。
7. epoll demo
这里只写epollserver，其余的代码模块与select和poll中的相同，代码如下：
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <sys/epoll.h>
#include <functional>
#include "err.h"
#include "log.hpp"
#include "sock.hpp"
namespace epoll_ns
{
class EpollServer
{
static const int defaultPort = 8081;
static const int size = 128;
static const int defaultValue = -1;
static const int defaultnum = 64;
using func_t = std::function<std::string (const string&)>;
public:
EpollServer(func_t func, uint16_t port = defaultPort, int num = defaultnum)
:_func(func)
,_num(num)
,_port(port)
{
}
void initServer()
{
// 1.创建socket
_listenSock = Sock::Socket();
Sock::Bind(_listenSock, _port);
Sock::Listen(_listenSock);
// 2.创建epoll模型
_epfd = epoll_create(size);
if(_epfd < 0)
{
logMessage(FATAL, "epoll create error: %s", strerror(errno));
exit(EPOLL_CREATE_ERR);
}
// 3.添加listensock到epoll中
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = _listenSock; // 当事件就绪 被重新捞取上来的时候，我们要知道是哪一个fd就绪了
epoll_ctl(_epfd, EPOLL_CTL_ADD, _listenSock, &ev);
// 4.申请就绪时间的空间
_revs = new struct epoll_event[_num];
logMessage(NORMAL, "init server success!");
}
void Print(int readyNum)
{
std::cout << "fd list: ";
for(int i = 0; i < readyNum; i++)
{
std::cout << _revs[i].data.fd << " ";
}
std::cout << std::endl;
}
void HandlerEvent(int readyNum)
{
logMessage(DEBUG, "Handler in");
for(int i = 0; i < readyNum; i++)
{
uint32_t events = _revs[i].events;
int sock = _revs[i].data.fd;
Print(readyNum);
if(sock == _listenSock && (events & EPOLLIN))
{
// _listensock的读事件就绪，获取新连接
std::string clientip;
uint16_t clientport;
int fd = Sock::Accept(sock, &clientip, &clientport);
if(fd < 0)
{
logMessage(WARNING, "accept error");
continue;
}
// 获取新的fd成功，可以直接读取吗？不能直接读取，可能会阻塞，将其放入epoll中
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = fd;
epoll_ctl(_epfd, EPOLL_CTL_ADD, fd, &ev);
}
else if(events & EPOLLIN)
{
// 普通的读事件就绪
// 读取是有问题的 没有协议定制
logMessage(DEBUG, "recv start");
char buffer[1024];
// 把本轮读完也不一定读到一个完整的请求
int n = recv(sock, buffer, sizeof(buffer)-1, 0);
if(n > 0)
{
buffer[n] = 0;
logMessage(DEBUG, "client# %s", buffer);
std::string response = _func(buffer);
send(sock, response.c_str(), response.size(), 0);
}
else if(n == 0)
{
// 建议先从epoll溢出，才close 文件描述符
epoll_ctl(_epfd, EPOLL_CTL_DEL, sock, nullptr);
close(sock);
logMessage(NORMAL, "client quit");
}
else
{
epoll_ctl(_epfd, EPOLL_CTL_DEL, sock, nullptr);
close(sock);
logMessage(ERROR, "recv error, code: %d, errstring: %s", errno, strerror(errno));
}
}
else if(events & EPOLLOUT)
{}
}
logMessage(DEBUG, "Handler out");
}
void start()
{
int timeout = -1;
for(;;)
{
int n = epoll_wait(_epfd, _revs, _num, timeout);
switch(n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "epoll_wait failed, code: %d, errstring: %s", errno, strerror(errno));
break;
default:
logMessage(NORMAL, "have event ready");
HandlerEvent(n); // 有n个事件就绪
break;
}
}
}
~EpollServer()
{
if(_listenSock != defaultValue) close(_listenSock);
if(_epfd != defaultValue) close(_epfd);
if(_revs) delete[] _revs;
}
private:
uint16_t _port;
int _listenSock;
int _epfd;
struct epoll_event *_revs;
int _num;
func_t _func;
};
}得到的实验结果也是与预期相符的：
8. 再谈epoll原理 (LT/ET)
什么叫做事件就绪：底层的IO条件满足了，可以进行某种IO行为了。
select/poll/epoll 为等待 ：IO就绪事件的通知机制
通知机制的策略，epoll的不同工作模式：
- Level Triggered(LT)：水平触发，只要底层有数据epoll就会一直通知用户要读取数据
- Edge Triggered(ET)：边缘触发，底层如果数据没有被读完，epoll不在通知用户，除非底 层数据变化的时候(数据增多)，才会再一次通知一次
select/poll/epoll默认工作模式为LT
EP模式只有数据从无到有/从有到多的时候，才会通知上层且只通知一次。使得程序员将本轮就绪的数据全部读取到上层，那么是如何吧本次就绪的底层数据全部读完的呢？-- 循环读取，直到读不到数据；一般的fd是阻塞式的，但是ET模式下对应的fd必须是非阻塞式的，因为若是我们读到最后一次底层没有数据时，阻塞式的fd会导致程序在读取时阻塞。
在epoll采用ET（Edge Triggered）工作模式时，如果一次没有读完底层来的数据，epoll_wait将不会再次触发事件，直到数据完全被读取或者关闭连接。这意味着，如果数据处理不完全，代码可能会阻塞在epoll_wait上，等待更多数据。
LT的fd可以是阻塞/非阻塞的。LT模式下也可以模仿ET的工作方式。并不能说LT/ET谁的工作模式更高效，要结合特定的场景来看。
一般情况下，ET的高效不只体现在通知机制上，还有会尽快让上层把数据取走。-- 当上层把数据取走后TCP可以更新出一个更大的滑动窗口，提高底层的发送效率，更阿红的利用诸如TCP应答机制等策略。 -- TCP中PSH的作用就是让底层数据就绪，再让上层知道。
扫一扫
603
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
