好用的epoll接口封装

最新推荐文章于 2020-11-26 12:04:25 发布
最新推荐文章于 2020-11-26 12:04:25 发布
阅读量869 收藏
点赞数
分类专栏： c++ 文章标签： epoll 接口 封装 好用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nullzhou/article/details/37872813
版权 
/// epoll接口封装
/// @file
/// @date 2012-02-14 15:21:53
/// @version 1.0.0
/// @author Zhou Ling(周龄), zhou.0@foxmail.com
/// @namespace hydra

#ifndef __HYDRA_EPOLLER_H__
#define __HYDRA_EPOLLER_H__ \
        "$Id: epoller.h 1519 2014-05-23 12:18:56Z zhouling $"

#include <sys/epoll.h>
#include "hydra_base_define.h"

namespace hydra {

/// @attention
/// 1: 系统的epoll_event很难用, 比如fd跟u32对应同一个内存块，名字不一样而已,
///    不能将fd跟u32用于存取不同的值，从epoll_event提取字段也不方便，
///    所以这里将epoll_event重新定义为EpollEvent。
/// 2: EpollEvent只是跟epoll_event大小相同而已，内存上字段并不完全对应, 所以
///    使用时以EpollEvent为准，epoll_event只作为Epoller内部使用
/// 3: EpollEvent字段引用比epoll_event要方便，举例如下：
///    EpollEvent myevent;                 epoll_event sysevent;
///    myevent.events                   vs sysevent.events
///    myevent.fd(!= myevent.u32)       vs sysevent.data.fd(== sysevent.data.u32)
///    myevent.u32(!= myevent.fd)       vs sysevent.data.u32(== sysevent.data.fd)
///    myevent.u64(== fd|u32 or u32|fd) vs sysevent.data.u64(包含fd/u32)
///    myevent.ptr                      vs sysevent.data.ptr
/// 4: 在调用 带参数uint32_t/uint64_t data的重载函数时，编译器可能报
///    ambiguous错误，需要给data参数加U/ULL后缀或者进行类型强转以去除二义性。有试
///    过命名成2个不同的函数，但是发现容易调用到错误的函数从而引起bug，这里的二义
///    性报错反而对调用者进行了提示，从而避免错误接口的调用！
struct EpollEvent
{
    uint32_t events; // Epoll events
    union // User data variable
    {
        struct
        {
            int fd;
            uint32_t u32;
        };
        uint64_t u64;
        void*    ptr;
    };
} __attribute__((__packed__));

class Epoller
{
public:
    Epoller(int trigger = 0); // 默认水平触发, 边沿触发填EPOLLET
    ~Epoller();

public:

    /// @brief epoll初始化
    /// @param[in] num epoll的初始fd监听个数
    /// @return 0 if succ, errcode if fail
    int Create(int num);

    /// @brief epoll轮询
    /// @param[in] timeout 轮询超时，毫秒
    /// @return 0: 无就绪事件，>0:就绪事件个数，<0:错误码
    int Wait(int timeout);

    /// @brief 将fd从epoll监听中删除
    /// @param[in] fd 需要删除的fd
    /// @return 0 if succ, errcode if fail
    int DelEvents(int fd);

    /// @brief 添加fd到epoll里面，用以监听其读事件
    /// @attention fd跟data都保存到EpollEvent
    /// @param[in] fd 需要监听的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int AddReadEvents(int fd, uint32_t data = 0);

    /// @brief 添加fd到epoll里面，用以监听其读事件
    /// @attention data保存到EpollEvent, fd没地方存
    /// @param[in] fd 需要监听的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int AddReadEvents(int fd, uint64_t data);

    /// @brief 添加fd到epoll里面，用以监听其读事件
    /// @attention ptr保存到EpollEvent, fd在x86_32下可存，x86_64下没地方存，统一不存
    /// @param[in] fd 需要监听的fd
    /// @param[in] ptr 需要保管的指针
    /// @return 0 if succ, errcode if fail
    int AddReadEvents(int fd, void* ptr);

    /// @brief 添加fd到epoll里面，用以监听其写事件
    /// @attention fd跟data都保存到EpollEvent
    /// @param[in] fd 需要监听的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int AddWriteEvents(int fd, uint32_t data = 0);

    /// @brief 添加fd到epoll里面，用以监听其写事件
    /// @attention data保存到EpollEvent, fd没地方存
    /// @param[in] fd 需要监听的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int AddWriteEvents(int fd, uint64_t data);

    /// @brief 添加fd到epoll里面，用以监听其写事件
    /// @attention ptr保存到EpollEvent, fd在x86_32下可存，x86_64下没地方存，统一不存
    /// @param[in] fd 需要监听的fd
    /// @param[in] ptr 需要保管的指针
    /// @return 0 if succ, errcode if fail
    int AddWriteEvents(int fd, void* ptr);

    /// @brief 添加fd到epoll里面，用以监听其读写事件
    /// @attention fd跟data都保存到EpollEvent
    /// @param[in] fd 需要监听的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int AddReadWriteEvents(int fd, uint32_t data = 0);

    /// @brief 添加fd到epoll里面，用以监听其读写事件
    /// @attention data保存到EpollEvent, fd没地方存
    /// @param[in] fd 需要监听的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int AddReadWriteEvents(int fd, uint64_t data);

    /// @brief 添加fd到epoll里面，用以监听其读写事件
    /// @attention ptr保存到EpollEvent, fd在x86_32下可存，x86_64下没地方存，统一不存
    /// @param[in] fd 需要监听的fd
    /// @param[in] ptr 需要保管的指针
    /// @return 0 if succ, errcode if fail
    int AddReadWriteEvents(int fd, void* ptr);

    /// @brief 改为监听读事件
    /// @attention fd跟data都保存到EpollEvent
    /// @param[in] fd 需要更改的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int ModifyToRead(int fd, uint32_t data = 0); 

    /// @brief 改为监听读事件
    /// @attention data保存到EpollEvent, fd没地方存
    /// @param[in] fd 需要更改的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int ModifyToRead(int fd, uint64_t data);

    /// @brief 改为监听读事件
    /// @attention ptr保存到EpollEvent, fd在x86_32下可存，x86_64下没地方存，统一不存
    /// @param[in] fd 需要更改的fd
    /// @param[in] ptr 需要保管的指针
    /// @return 0 if succ, errcode if fail
    int ModifyToRead(int fd, void* ptr);

    /// @brief 改为监听写事件
    /// @attention fd跟data都保存到EpollEvent
    /// @param[in] fd 需要更改的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int ModifyToWrite(int fd, uint32_t data = 0);

    /// @brief 改为监听写事件
    /// @attention data保存到EpollEvent, fd没地方存
    /// @param[in] fd 需要更改的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int ModifyToWrite(int fd, uint64_t data);

    /// @brief 改为监听写事件
    /// @attention ptr保存到EpollEvent, fd在x86_32下可存，x86_64下没地方存，统一不存
    /// @param[in] fd 需要更改的fd
    /// @param[in] ptr 需要保管的指针
    /// @return 0 if succ, errcode if fail
    int ModifyToWrite(int fd, void* ptr);

    /// @brief 改为监听读写事件
    /// @attention fd跟data都保存到EpollEvent
    /// @param[in] fd 需要更改的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int ModifyToReadWrite(int fd, uint32_t data = 0);

    /// @brief 改为监听读写事件
    /// @attention data保存到EpollEvent, fd没地方存
    /// @param[in] fd 需要更改的fd
    /// @param[in] data 需要保管的数据
    /// @return 0 if succ, errcode if fail
    int ModifyToReadWrite(int fd, uint64_t data);

    /// @brief 改为监听读写事件
    /// @attention ptr保存到EpollEvent, fd在x86_32下可存，x86_64下没地方存，统一不存
    /// @param[in] fd 需要更改的fd
    /// @param[in] ptr 需要保管的指针
    /// @return 0 if succ, errcode if fail
    int ModifyToReadWrite(int fd, void* ptr);

    /// @brief 返回epoll观察到的就绪事件集合
    /// @return epoll观察到的就绪事件集合
    EpollEvent* GetEvents() const { return _events; }

    /// @brief 返回最近一次产生的错误信息
    /// @return 最近一次产生的错误信息
    const char* GetErrMsg() const { return _errmsg; }

private:
    int EpollControl(int op, uint32_t flag, int fd, uint32_t data);
    int EpollControl(int op, uint32_t flag, int fd, uint64_t data);
    int EpollControl(int op, uint32_t flag, int fd, void* ptr);
    int EpollControl(int op, int fd, EpollEvent event_unit);

private:
    char            _errmsg[128];
    EpollEvent*     _events;
    int             _epfd;
    int             _maxevents;
    int             _trigger;
    bool            _init;
};

}

#endif

/// cpp
#include "epoller.h"
#include "hydra_file_util.h"
#include "hydra_log.h"

namespace hydra {

Epoller::Epoller(int trigger)
{
    _errmsg[0] = 0;
    _events = NULL;
    _epfd = -1;
    _maxevents = -1;
    _trigger = trigger;
    _init = false;
}

Epoller::~Epoller()
{
    if (_events != NULL)
    {
        delete[] _events;
        _events = NULL;
    }
    hydra::Close(_epfd);
}

int Epoller::AddReadEvents(int fd, uint32_t data)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLIN, fd, data);
}

int Epoller::AddReadEvents(int fd, uint64_t data)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLIN, fd, data);
}

int Epoller::AddReadEvents(int fd, void* ptr)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLIN, fd, ptr);
}

int Epoller::AddWriteEvents(int fd, uint32_t data)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLOUT, fd, data);
}

int Epoller::AddWriteEvents(int fd, uint64_t data)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLOUT, fd, data);
}

int Epoller::AddWriteEvents(int fd, void* ptr)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLOUT, fd, ptr);
}

int Epoller::AddReadWriteEvents(int fd, uint32_t data)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLIN | EPOLLOUT, fd, data);
}

int Epoller::AddReadWriteEvents(int fd, uint64_t data)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLIN | EPOLLOUT, fd, data);
}

int Epoller::AddReadWriteEvents(int fd, void* ptr)
{
    return EpollControl(EPOLL_CTL_ADD, EPOLLIN | EPOLLOUT, fd, ptr);
}

int Epoller::ModifyToRead(int fd, uint32_t data)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLIN, fd, data);
}

int Epoller::ModifyToRead(int fd, uint64_t data)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLIN, fd, data);
}

int Epoller::ModifyToRead(int fd, void* ptr)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLIN, fd, ptr);
}

int Epoller::ModifyToWrite(int fd, uint32_t data)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLOUT, fd, data);
}

int Epoller::ModifyToWrite(int fd, uint64_t data)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLOUT, fd, data);
}

int Epoller::ModifyToWrite(int fd, void* ptr)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLOUT, fd, ptr);
}

int Epoller::ModifyToReadWrite(int fd, uint32_t data)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLIN | EPOLLOUT, fd, data);
}

int Epoller::ModifyToReadWrite(int fd, uint64_t data)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLIN | EPOLLOUT, fd, data);
}

int Epoller::ModifyToReadWrite(int fd, void* ptr)
{
    return EpollControl(EPOLL_CTL_MOD, EPOLLIN | EPOLLOUT, fd, ptr);
}

int Epoller::DelEvents(int fd)
{
    return EpollControl(EPOLL_CTL_DEL, 0U, fd, 0U);
}

int Epoller::EpollControl(int op, uint32_t flag, int fd, uint64_t data)
{
    EpollEvent event_unit;
    event_unit.events = flag | _trigger;
    event_unit.u64 = data;
    return EpollControl(op, fd, event_unit);
}

int Epoller::EpollControl(int op, uint32_t flag, int fd, void* ptr)
{
    EpollEvent event_unit;
    event_unit.events = flag | _trigger;
    event_unit.ptr = ptr;
    return EpollControl(op, fd, event_unit);
}

int Epoller::EpollControl(int op, uint32_t flag, int fd, uint32_t data)
{
    EpollEvent event_unit;
    event_unit.events = flag | _trigger;
    event_unit.fd = fd;
    event_unit.u32 = data;
    return EpollControl(op, fd, event_unit);
}

int Epoller::EpollControl(int op, int fd, EpollEvent event_unit)
{
    int ret = epoll_ctl(_epfd, op, fd, (epoll_event*)&event_unit);
    if (ret != 0)
    {
        SET_ERR_MSG("epoll_ctl(epfd=%d, op=%d, fd=%d) err: %m", _epfd, op, fd);
        return -errno;
    }

    return 0;
}

int Epoller::Create(int maxevents)
{
    if (_init) return 0;

    _epfd = epoll_create(maxevents);
    if (_epfd < 0)
    {
        SET_ERR_MSG("epoll_create(size=%d) fail: %m", maxevents);
        return -errno;
    }

    _events = new EpollEvent[maxevents];
    if (NULL == _events)
    {
        SET_ERR_MSG("new EpollEvent err: %m, sizeof(EpollEvent)=%u, maxevents=%d",
                (uint32_t)sizeof(EpollEvent), maxevents);
        int err = -errno;
        hydra::Close(_epfd);
        return err;
    }

    _maxevents = maxevents;
    _init = true;
    return 0;
}

int Epoller::Wait(int timeout)
{
    int nevents = 0;
    while ((nevents = epoll_wait(_epfd, (epoll_event*)_events, _maxevents, timeout))
            < 0 && EINTR == errno)
        ; // do nothing

    if (nevents < 0)
    {
        SET_ERR_MSG("epoll_wait(epfd=%d, maxevents=%d, timeout=%d) err: %m",
                _epfd, _maxevents, timeout);
        return -errno;
    }

    return nevents;
}

}

brk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++游戏服务器框架笔记(五)_封装Epoll
木可的博客
08-03 503
通用IO多路复用接口类封装之——epoll封装
epoll高度封装reactor,几乎所有可见服务器的底层框架
小杰312的博客
04-02 5178
epoll高度封装reactor,几乎所有可见服务器的底层框架
linux下epoll如何实现高效处理百万句柄的
yiyeqinghuasoon
01-06 1788
开发高性能网络程序时，windows开发者们言必称iocp，linux开发者们则言必称epoll。大家都明白epoll是一种IO多路复用技术，可以非常高效的处理数以百万计的socket句柄，比起以前的select和poll效率高大发了。我们用起epoll来都感觉挺爽，确实快，那么，它到底为什么可以高速处理这么多并发连接呢？ 先简单回顾下如何使用C库封装的3个epoll系统调用吧。 in...
Socket编程实践(11) --epoll原理与封装
weixin_30488085的博客
03-11 309
常用模型的特点 Linux下设计并发网络程序,有典型的Apache模型(ProcessPerConnection,PPC),TPC(ThreadPerConnection)模型，以及select/polL模型和epoll模型。1、PPC/TPC模型 这两种模型思想类似，就是让每一个到来的连接一边自己做事去，别再来烦我(详见本系列博客).只是PPC是为它开了一...
linux c++ epoll网络模型封装类 socket
09-01
封装了epoll功能，很简单的使用epoll，只需要指定epoll服务监听端口，就可以运行epoll服务。可以指定收到数据的回调函数，可以指定有连接的回调函数，可以指定网络关闭的回调函数。自己编写调试epoll模型可能要几天，这里只需要几分钟。代码中有详细的说明
高性能、高并发，封装了epoll的框架
03-30
封装了epoll，使其成为并发效率更高的框架，接口以及封装好，直接调用即可； 资源中main1.cpp是一个echo(回声)服务器案例，此案例就是调用了封装epoll的接口进行实现； 此epoll框架是我报班的老师分享，听说这是他...
linux epoll的封装类
01-14
这个“linux epoll的封装类”是为了简化epoll接口的使用，使得初学者能够更轻松地理解和应用epoll机制。 epoll的工作原理主要是通过`epoll_create`、`epoll_ctl`和`epoll_wait`这三个核心函数来实现。`epoll_create...
自己封装的epoll事件驱动模型
04-25
**epoll接口** epoll主要提供了以下几个核心接口： 1. `epoll_create()`: 创建一个epoll实例，返回一个epoll文件描述符。 2. `epoll_ctl()`: 对epoll实例进行管理，可以添加、删除或修改监听的文件描述符及其事件...
主要用于处理网络IO事件基于epoll封装的库和框架 .rar
最新发布
06-11
epoll的接口非常简单，一共就三个函数： 1. int epoll_create(int size); 2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) 3. int epoll_wait(int epfd, struct epoll_event * events, int...
epoll 获取串口数据（封装为函数）
12-13
把epoll接收数据封装为接口形式供线程调用
windows下udt库实现epoll的demo
08-19
利用udt.sdk.4.11的库，在windows下简单实现了epoll功能
Epoll的C++封装
无相
12-28 1840
之前因工作需要，封装的一个，贴出来供参考和使用。 使用上，主要也是wait它，再利用重载的[]操作符进行操作，让人感觉更清晰明了一点。 #ifndef EPOLL_H #define EPOLL_H #include &lt;sys/epoll.h&gt; #include &lt;unistd.h&gt; /** * @brief The Epoll class 对epoll的封...
python语法基础知识大全
summer
08-31 1161
IDE：pycharm 参考书籍：《Python编程：从入门到实践》--埃里克.玛瑟斯 适合人群：有点编程基础 一、变量和简单数据类型 1.变量名只能包含字母、数字和下划线。可以以字母和下划线开头，但是不能从数字开头；变量名不能包含空格 2.数据类型--字符串 字符串可以用双引号或者单引号括起来，两者作用一样。具体选择哪种，要看字符串里面的内容，如果字符串里面包含单引号，那么外面就要使...
epoll封装成类
wqw1672的博客
08-20 410
epoll封装成类 epoll基本信息 epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并 发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结 果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点 原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件 异步唤醒...
C++封装一个Epoll类，实现epoll简单使用
giturtle's blog
06-19 3263
#include <iostream> #include <vector> #include <sys/epoll.h> #include "tcpsocket.hpp" class Epoll { private: int _epfd; public: bool Init() { //创...
封装poll和epoll
sdjn_lyn的博客
01-09 329
在select、poll和epoll详解中提到了可以对poll和epoll进行封装，提供统一的接口。封装目的主要有两个：复用和易用，以下封装希望屏蔽poll和epoll使用时的诸多细节，提供简单易用的接口 珠玉在前，本文所提供的代码参考自muduo网络库，另外代码有用到tools-cxx中提供的base库和log库 框架 首先看一下整体类图： PollPoller和EPollPoller分别对p...
C++ Epoll的封装
浮白
04-04 8190
Epoller组件的实现主要是对于epoll_create,epoll_ctl,epoll_wait等的封装,该Epoll可以设置 可选择采用边缘触发还是选择触发的模式bEt，默认为边缘触发 可指定该Epoll可以指定监听的最大套接字数目max_connections /**  * @brief epoller操作类，已经默认采用了EPOLLET方式做触发  */ c
PHP实现小型博客网站
云淡风轻ing的博客
11-26 706
工具型博客网站（程序员网站）：红尘客栈 支持发表文章 支持浏览评论 支持多用户注册 网站功能还比较简洁，页面也没有太多特效，使用HTML与PHP实现，开发者想要新加功能的话也比较方便。 源代码：https://github.com/haohaizhi/hongchen_blog.git ...
epoll 封装
imsjw
03-10 164
dwsocket.h #pragma once #include &lt;string&gt; #include &lt;sys/epoll.h&gt; namespace dw { using namespace std; class Addr { public: int port; string ip; Addr(string ip, int port); Ad...
epoll_ctl用封装的还是用原接口
05-16
在使用 epoll_ctl 函数时，可以根据具体情况选择使用封装的函数还是原始的接口。使用封装的函数可以提高代码的可读性和可维护性，同时可以封装一些常见的错误处理逻辑，提高代码的健壮性。但是，如果需要使用 epoll_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值