[源码阅读]——Sylar服务器框架：IO协程调度模块
IO协程调度模块
-
- epoll相关
-
- 内核事件表
- epoll_wait函数
- LT和ET模式
- EPOLLONESHOT事件
- IO协程调度模块概述
- IO协程调度器具体实现
- 总结
epoll相关
内核事件表
epoll是Linux特有的I/O复用函数。其使用一组函数来完成任务，将用户关心的文件描述符上的事件放在内核里的一个时间表中，无需像select和poll每次调用都要重复传入文件描述符集或事件集。epoll需要使用一个额外的文件描述符，来比唯一标识内核中的事件表。
#include
// 创建文件描述符
// size只是提示事件表大小
int epoll_create(int size);
// 该函数返回将用作其他所有epoll系统调用的第一个参数，以指定要访问的内核事件表
// 操作epoll的内核事件表
// fd：要操作的文件描述符
// op：指定操作类型：EPOLL_CTL_ADD(往事件表注册fd上的事件)；EPOLL_CTL_MOD(修改fd上的注册事件)；EPOLL_CTL_DEL(删除fd上的事件)
// event：指定事件，是epoll_event结构指针类型
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
// 调用成功时候返回0，失败返回-1并设置errno
// epoll_event结构定义
struct epoll_event{
__uint32_t events; // epoll事件
epoll_data_t data; // 用户数据
};
// epoll_data_t是一个联合体，fd指定事件从属的目标描述符；ptr指定fd相关用户数据。
typedef union epoll_data{
void* ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
epoll_wait函数
epoll_wait是在一段超时时间内等待一组文件描述符上的事件。
#include
// maxevents指定最多监听多少个事件
// timeout定义超时时间
int epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout);
// 成功时返回就绪的文件描述符的个数，失败时返回-1，并设置errno；
// epoll_wait函数如果检测到时间，就将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中，该数组只用于输出epoll_wait检测到的就绪事件。
// select和poll即传入用户注册的事件，又输出内核检测到的就绪事件
举例：
// 如何索引epoll返回的就绪文件描述符
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
// 遍历就绪的ret文件描述符
for(int i=0;iLT和ET模式
epoll对文件描述符的操作有两种：LT(电平触发模式)和ET(边缘触发模式)。其中默认位LT，其相当于效率较高的poll。当往epoll内河事件表注册一个文件描述符上的EPOLLET事件时，epoll将以ET模式来操作该文件描述符。ET模式是epoll的高效工作模式。
采用LT工作模式的文件描述符，当epoll_wait检测到其上有事件发生并将此通知给应用程序后，应用程序可以不立即处理该事件。当应用程序下次调用epoll_wait时，epoll_wait还会再次想用应用程序告知此事件，直到该事件被处理。
采用ET工作模式的文件描述符，当epoll_wait检测到其上有时间通知应用程序后，应用程序必须立即处理该事件，后续epoll_wait将不再向应用程序通知这一事件。因此ET模式降低了同一个epoll事件被重复出发的次数，效率比LT模式高。
EPOLLONESHOT事件
即使使用ET模式，一个socket上的某个事件还是可能被触发多次，因此在并发程序中，若一个线程读取完某个socket上的数据后开始处理这些数据，若是该socket又有新数据可读，此时另外的线程被唤醒读取新数据，导致两个线程同时操作一个socket局面。
对于注册了EPOLLONESHOT事件的文件描述符，操作系统中最多出发其注册的的一个可读、可写或异常事件，且只能触发一次。这样，一个线程处理某个socket时，其他线程无法操作该socket。同hi，注册了EPOLLONESHOT事件的socket一旦被讴歌线程处理完毕，该线程将立即重置这个socket上的EPOLLONESHOT事件，确保这个socket下次可读时，EPOLLIN事件能被触发。
IO协程调度模块概述
在sylar的IO协程调度模块中，其直接继承了之前的协程调度器，基于epoll实现。其主要增加了IO事件调度功能、idle和tickle的重写、epoll事件的分类和取消事件的功能。具体的整个IO协程调度去阅读不是很难，但个人感觉如果对epoll这些编程不熟悉的话，对整个的理解是有点困难的，可以从一些简单的程序开始阅读理解，比如《Linux高性能编程》这本书看一看。
整的来看其实IO协程调度模块就是对之前的协程调度器进行了改在，然后结合epoll实现了IO事件的添加、取消、调度等功能。这里是使用的非阻塞IO，将嵌套字设置成非阻塞状态，然后与回调函数绑定，基于epoll_wait等待事件的发生。
在和别人讨论的过程中，很多大佬都表示IO这里是整个sylar框架中最有用或者最值得学习的内容，而且也是整个框架的核心部分，但是本人能力有限，无法更加深入的探究这个模块的精髓，只能结合程序去理解整个模块的设计以及大致功能。
IO协程调度器具体实现
首先sylar基于epoll对事件的定义，重新定义了IO事件，这里这里sylar仅关心读时间、写事件，其他的epoll事件都会将其归类于读写两类中
enum Event{
NONE = 0x0, // 无事件
READ = 0x1, // 读事件
WRITE = 0x4 // 写事件
};
随后定义了socket事件上下文，每一个socket fd都对应了一个FdContext，包括fd、fd的事件、fd事件上下文，其中事件上下文用于保存这个事件的回调函数、执行回调函数的调度器。
// socket事件上下文类
struct FdContext{
typedef Mutex MutexType;
// 事件上下文类
// fd的每一个事件都有一个事件上下文，保存相关内容
struct EventContext{
Scheduler* scheduler = nullptr; // 事件执行调度器
Fiber::ptr fiber; // 事件的协程
std::function cb; // 事件的回调函数
};
// 获取上下文类
EventContext& getContext(Event event);
// 重置事件上下文类
void resetContext(EventContext& ctx);
// 触发事件
void triggerEvent(Event event);
EventContext read; // 读事件
EventContext write; // 写事件
int fd; // 事件关联的句柄
Event events = NONE; // 已注册的事件
MutexType mutex;
};
接着就是IOManager的几个主要方法和参数，首先是其private参数：
// epoll 文件句柄
int m_epfd = 0;
// pipe 文件句柄，fd[0]读端，fd[1]写端
int m_tickleFds[2];
// 当前等待执行的事件数量：原子操作
std::atomic m_pendingEventCount = {0};
// IOManager的Mutex
RWMutexType m_mutex;
// socket事件上下文的容器
std::vector m_fdContexts;
由于IOManager继承Schedule，所以其构造函数在首先要初始化一个scheduler，随后添加了支持epoll的功能，将其设置为非阻塞边缘触发。
// IOManager(size_t threads = 1, bool use_caller = true, const std::string& name = "");
IOManager::IOManager(size_t threads, bool use_caller, const std::string& name)
:Scheduler(threads, use_caller, name) {
// 创建文件描述符，返回将作用其他所有epoll系统调用的第一个参数，以指定要访问的内河事件表
m_epfd = epoll_create(5000);
SYLAR_ASSERT(m_epfd > 0);
// 创建一个管道pipe，获取m_tickleFds[2]。
int rt = pipe(m_tickleFds);
SYLAR_ASSERT(!rt);
// 注册pipe读句柄的可读事件，用于tickle调度协程，通过epoll_event.data.fd保存描述符
epoll_event event;
// 将&event后面sizeof(epooll_event)的地址置0；
memset(&event, 0, sizeof(epoll_event));
event.events = EPOLLIN | EPOLLET;
event.data.fd = m_tickleFds[0];
// 设置文件句柄 m_tickleFds[0]，非阻塞方式，配合边缘触发
rt = fcntl(m_tickleFds[0], F_SETFL, O_NONBLOCK);
SYLAR_ASSERT(!rt);
// 操作epoll内核事件表，EPOLL_CTL_ADD：往事件表注册fd上的事件
// 将管道的读描述符加入到epoll多路复用，如果管道可读，idle中的epoll_wait会返回
rt = epoll_ctl(m_epfd, EPOLL_CTL_ADD, m_tickleFds[0], &event);
SYLAR_ASSERT(!rt);
contextResize(32);
start(); // 开启调度，也就是说当IOManager创建时，就自动开始调度
}
而析构函数则是停止调度，关闭句柄，释放空间。
IOManager::~IOManager(){
stop(); // 关闭调度
close(m_epfd);
close(m_tickleFds[0]);
close(m_tickleFds[1]);
for(size_t i=0;i相比于schedule，IOManager是增加了添加事件、删除事件、取消事件等功能的，其中删除事件是不会触发事件的，但是取消事件和取消所有事件都会触发一次事件。
// 1 success, 0 retry, -1 error
int IOManager::addEvent(int fd, Event event, std::function cb) {
// 找到fd对应的FdContext，如果不存在，则分配一个
FdContext* fd_ctx = nullptr;
RWMutexType::ReadLock lock(m_mutex);
if((int)m_fdContexts.size() > fd) {
fd_ctx = m_fdContexts[fd];
lock.unlock();
}
else {
lock.unlock();
RWMutexType::WriteLock lock2(m_mutex);
contextResize(fd * 1.5);
fd_ctx = m_fdContexts[fd];
}
// 同一个fd不允许重复添加相同的事情
FdContext::MutexType::Lock lock2(fd_ctx->mutex);
if(SYLAR_UNLIKELY(fd_ctx->events & event)) {
SYLAR_LOG_ERROR(g_logger) << "addEvent assert fd=" << fd
<< " event=" << (EPOLL_EVENTS)event
<< " fd_ctx.event=" << (EPOLL_EVENTS)fd_ctx->events;
SYLAR_ASSERT(!(fd_ctx->events & event));
}
// 将新事件加入到epoll_wait，使用epoll_event的私有指针存储FdContext
// EPOLL_CTL_MOD：修改fd上的事件
int op = fd_ctx->events ? EPOLL_CTL_MOD : EPOLL_CTL_ADD;
epoll_event epevent;
epevent.events = EPOLLET | fd_ctx->events | event;
epevent.data.ptr = fd_ctx;
int rt = epoll_ctl(m_epfd, op, fd, &epevent);
if(rt) {
SYLAR_LOG_ERROR(g_logger) << "epoll_ctl(" << m_epfd << ", "
<< (EpollCtlOp)op << ", " << fd << ", " << (EPOLL_EVENTS)epevent.events << "):"
<< rt << " (" << errno << ") (" << strerror(errno) << ") fd_ctx->events="
<< (EPOLL_EVENTS)fd_ctx->events;
return -1;
}
// 将待执行IO事件加一
++m_pendingEventCount;
// 找到这个fd的event事件对应的EventContext，对其中的scheduler，cb，fiber进行赋值
fd_ctx->events = (Event)(fd_ctx->events | event);
FdContext::EventContext& event_ctx = fd_ctx->getContext(event);
SYLAR_ASSERT(!event_ctx.scheduler
&& !event_ctx.fiber
&& !event_ctx.cb);
// 复制scheduler和回调函数，如果回调函数为空，则将当前协程设为回调执行体
event_ctx.scheduler = Scheduler::GetThis();
if(cb) {
event_ctx.cb.swap(cb);
} else {
event_ctx.fiber = Fiber::GetThis();
SYLAR_ASSERT2(event_ctx.fiber->getState() == Fiber::EXEC
,"state=" << event_ctx.fiber->getState());
}
return 0;
}
bool IOManager::delEvent(int fd, Event event){
// 找到fd对应的FdContext
RWMutexType::ReadLock lock(m_mutex);
if((int)m_fdContexts.size() <= fd) {
return false;
}
FdContext* fd_ctx = m_fdContexts[fd];
lock.unlock();
FdContext::MutexType::Lock lock2(fd_ctx->mutex);
if(SYLAR_UNLIKELY(!(fd_ctx->events & event))) {
return false;
}
// 清除指定的事件，表示不关心这个事件了，如果清除之后结果为0，则从epoll_wait中删除该文件描述符
Event new_events = (Event)(fd_ctx->events & ~event);
int op = new_events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL;
epoll_event epevent;
epevent.events = EPOLLET | new_events;
epevent.data.ptr = fd_ctx;
int rt = epoll_ctl(m_epfd, op, fd, &epevent);
if(rt) {
SYLAR_LOG_ERROR(g_logger) << "epoll_ctl(" << m_epfd << ", "
<< op << ", " << fd << ", " << (EPOLL_EVENTS)epevent.events << "):"
<< rt << " (" << errno << ") (" << strerror(errno) << ")";
return false;
}
// 待执行事件数减1
--m_pendingEventCount;
// 重置该fd对应的event事件上下文
fd_ctx->events = new_events;
FdContext::EventContext& event_ctx = fd_ctx->getContext(event);
fd_ctx->resetContext(event_ctx);
return true;
}
bool IOManager::cancelEvent(int fd, Event event){
RWMutexType::ReadLock lock(m_mutex);
if((int)m_fdContexts.size() <= fd) {
return false;
}
FdContext* fd_ctx = m_fdContexts[fd];
lock.unlock();
FdContext::MutexType::Lock lock2(fd_ctx->mutex);
if(SYLAR_UNLIKELY(!(fd_ctx->events & event))) {
return false;
}
Event new_events = (Event)(fd_ctx->events & ~event);
int op = new_events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL;
epoll_event epevent;
epevent.events = EPOLLET | new_events;
epevent.data.ptr = fd_ctx;
int rt = epoll_ctl(m_epfd, op, fd, &epevent);
if(rt) {
SYLAR_LOG_ERROR(g_logger) << "epoll_ctl(" << m_epfd << ", "
<< op << ", " << fd << ", " << (EPOLL_EVENTS)epevent.events << "):"
<< rt << " (" << errno << ") (" << strerror(errno) << ")";
return false;
}
// 取消会触发事件
fd_ctx->triggerEvent(event);
--m_pendingEventCount;
return true;
}
bool IOManager::cancelAll(int fd){
RWMutexType::ReadLock lock(m_mutex);
if((int)m_fdContexts.size() <= fd) {
return false;
}
FdContext* fd_ctx = m_fdContexts[fd];
lock.unlock();
FdContext::MutexType::Lock lock2(fd_ctx->mutex);
if(!fd_ctx->events) {
return false;
}
int op = EPOLL_CTL_DEL;
epoll_event epevent;
epevent.events = 0;
epevent.data.ptr = fd_ctx;
int rt = epoll_ctl(m_epfd, op, fd, &epevent);
if(rt) {
SYLAR_LOG_ERROR(g_logger) << "epoll_ctl(" << m_epfd << ", "
<< op << ", " << fd << ", " << (EPOLL_EVENTS)epevent.events << "):"
<< rt << " (" << errno << ") (" << strerror(errno) << ")";
return false;
}
// 取消所有事件(读、写)
if(fd_ctx->events & READ) {
fd_ctx->triggerEvent(READ);
--m_pendingEventCount;
}
if(fd_ctx->events & WRITE) {
fd_ctx->triggerEvent(WRITE);
--m_pendingEventCount;
}
SYLAR_ASSERT(fd_ctx->events == 0);
return true;
}
最后便是tickle、idle、stopping这些方法的重写，其中tikcle会向m_tickleFds写一个字节作为通知，而idle则是本人认为最重要的一部分，已经做了大量的注释大家可以直接参考：
// 写pipe让idle协程从epoll_wait退出，待idle协程yield之后Scheduler::run就可以调度其他任务
// 如果当前没有空闲调度线程，那就没必要发通知
void IOManager::tickle() {
if(!hasIdleThreads()) {
// 若当前没有空闲调度线程，就不发送通知
return;
}
int rt = write(m_tickleFds[1], "T", 1);
SYLAR_ASSERT(rt == 1);
}
bool IOManager::stopping(uint64_t& timeout) {
timeout = getNextTimer();
// 对于IOManager而言，必须等所有待调度的IO事件都执行完了才可以退出
return timeout == ~0ull
&& m_pendingEventCount == 0
&& Scheduler::stopping();
}
bool IOManager::stopping() {
uint64_t timeout = 0;
return stopping(timeout);
}
/**
* @brief idle协程
* 对于IO协程调度来说，应阻塞在等待IO事件上，idle退出的时机是epoll_wait返回，对应的操作是tickle或注册的IO事件就绪
* 调度器无调度任务时会阻塞idle协程上，对IO调度器而言，idle状态应该关注两件事
* 一是有没有新的调度任务，对应Schduler::schedule()，如果有新的调度任务，那应该立即退出idle状态，并执行对应的任务；
* 二是关注当前注册的所有IO事件有没有触发，如果有触发，那么应该执行IO事件对应的回调函数
*/
void IOManager::idle() {
SYLAR_LOG_DEBUG(g_logger) << "idle";
// 一次epoll_wait最多检测256个就绪事件，如果就绪事件超过了这个数，那么会在下轮epoll_wati继续处理
const uint64_t MAX_EVNETS = 256;
epoll_event* events = new epoll_event[MAX_EVNETS]();
std::shared_ptr shared_events(events, [](epoll_event* ptr){
delete[] ptr;
});
while(true) {
uint64_t next_timeout = 0;
if(SYLAR_UNLIKELY(stopping(next_timeout))) {
SYLAR_LOG_INFO(g_logger) << "name=" << getName()
<< " idle stopping exit";
break;
}
int rt = 0;
// do while结构至少会执行一次
do {
static const int MAX_TIMEOUT = 3000;
if(next_timeout != ~0ull) {
next_timeout = (int)next_timeout > MAX_TIMEOUT
? MAX_TIMEOUT : next_timeout;
}
else {
next_timeout = MAX_TIMEOUT;
}
// 阻塞在epoll_wait上，等待事件发生
rt = epoll_wait(m_epfd, events, MAX_EVNETS, (int)next_timeout);
if(rt < 0 && errno == EINTR) {
}
else {
break;
}
} while(true);
std::vector > cbs;
// 获取所需要执行的定时器的回调函数列表
listExpiredCb(cbs);
if(!cbs.empty()) {
// 调度需要执行的定时器回调函数
schedule(cbs.begin(), cbs.end());
cbs.clear();
}
// 遍历所有发生的事件，根据epoll_event的私有指针找到对应的FdContext，进行事件处理
for(int i = 0; i < rt; ++i) {
epoll_event& event = events[i];
if(event.data.fd == m_tickleFds[0]) {
// ticklefd[0]用于通知协程调度，这时只需要把管道里的内容读完即可
// 本轮idle结束Scheduler::run会重新执行协程调度
uint8_t dummy[256];
while(read(m_tickleFds[0], dummy, sizeof(dummy)) > 0);
continue;
}
// 通过epoll_event的私有指针获得FdContext
FdContext* fd_ctx = (FdContext*)event.data.ptr;
FdContext::MutexType::Lock lock(fd_ctx->mutex);
/**
* EPOLLERR: 出错，比如写读端已经关闭的pipe
* EPOLLHUP: 套接字对端关闭
* 出现这两种事件，应该同时触发fd的读和写事件，否则有可能出现注册的事件永远执行不到的情况
*/
if(event.events & (EPOLLERR | EPOLLHUP)) {
event.events |= (EPOLLIN | EPOLLOUT) & fd_ctx->events;
}
int real_events = NONE;
if(event.events & EPOLLIN) {
real_events |= READ;
}
if(event.events & EPOLLOUT) {
real_events |= WRITE;
}
if((fd_ctx->events & real_events) == NONE) {
continue;
}
// 剔除已经发生的事件，将剩下的事件重新加入epoll_wait，
// 如果剩下的事件为0，表示这个fd已经不需要关注了，直接从epoll中删除
int left_events = (fd_ctx->events & ~real_events);
int op = left_events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL;
event.events = EPOLLET | left_events;
int rt2 = epoll_ctl(m_epfd, op, fd_ctx->fd, &event);
if(rt2) {
SYLAR_LOG_ERROR(g_logger) << "epoll_ctl(" << m_epfd << ", "
<< op << ", " << fd_ctx->fd << ", " << (EPOLL_EVENTS)event.events << "):"
<< rt2 << " (" << errno << ") (" << strerror(errno) << ")";
continue;
}
// 处理已经发生的事件，也就是让调度器调度指定的函数或协程
if(real_events & READ) {
fd_ctx->triggerEvent(READ);
--m_pendingEventCount;
}
if(real_events & WRITE) {
fd_ctx->triggerEvent(WRITE);
--m_pendingEventCount;
}
}
/**
* 一旦处理完所有的事件，idle协程yield，这样可以让调度协程(Scheduler::run)重新检查是否有新任务要调度
* 上面triggerEvent实际也只是把对应的fiber重新加入调度，要执行的话还要等idle协程退出
*/
Fiber::ptr cur = Fiber::GetThis();
auto raw_ptr = cur.get();
cur.reset();
raw_ptr->swapOut();
}
}
总结
关于IOManager的用法在后面经常使用，具体使用方法可以多结合测试案例去了解，本人觉得整个IOManager的源码阅读不算困难，主要是要理清设计的目的这些，我个人也只是这两天才慢慢看懂在做什么，之前因为schedule模块看的也不是很清晰，所以这里一直是云里雾里，所以学习IOManager这一模块必须对前面的协程调度非常熟悉，又有一定的epoll相关知识，阅读和理解起来才会相对轻松点~