hpserver

class CReactor
{
    IReactor_Imp *m_pImp; // real implementation.内部有一个Reactor实现，主要是负责进行poll方面的工作
    std::vector<DTEV_ITEM *> m_vecActiveList[MAX_EV_PRIORITY]; // current active events in each loop.当前活跃事件，注意这里类型是DTEV_ITEM*
    int m_activeHandlers; // 当前有多少个活跃handlers.
    IEventScheduler *m_pScheduler; // 调度策略，就是对于一系列活跃事件处理顺序如何
    CDefScheduler    m_defScheduler; // 默认调度策略
    CDemuxTable   *m_tabIoHandlers; // DemuxTable.用来将fd到DETV_ITEM映射
    CSignalSet    *m_setSigHandlers; // SignalSet,内部是EventHandler到DTEV_ITEM的映射
    CMinHeap      *m_timerHeap; // 最小堆，用来实现定时器
    CSignalInfo   *m_sigInfo; // 信号量和DTEV_ITEM的映射
    struct timeval m_time; // last dispatch return time.上次disptach之前的时间
    struct timeval m_timeCache; // caches dispatch return time.m_timeCache.
    volatile bool m_bRunning, m_bNeedStop; // 是否在运行，是否需要停止
};

class IReactor_Imp
{
    // initialize I/O method and set event factory
    virtual int Initialize(CReactor *pReactor) = 0;
    virtual int Finalize() = 0;
    virtual int Dispatch(struct timeval *tv) = 0; // 这里的tv表示进行poll的超时时间
    // get kernel mechanism
    virtual const tchar *GetMethod() = 0;

    // register event read/write
    // @event: EV_READ or EV_WRITE
    virtual int RegisterEvent(const DTEV_ITEM *pEvItem, short event) = 0; // event item关注event.
    // unregister event read/write
    // @event: EV_READ or EV_WRITE
    virtual int UnregisterEvent(const DTEV_ITEM *pEvItem, short event) = 0; // event item不关注event.
};

struct DTEV_ITEM // event item structure
{
    const void *pHandler; // event handler/completion handler the handle binded to.绑定到一个Handler上面
    HL_SOCKET      handle; // hande of the event item, in linux it's the same as the index in DTEV_ITEM array
    short events, evActive; // 我们关注的events以及活跃的events.
    short nsigs; // for signals.信号触发了多少次，这个对于pending信号来说有效
    short flags; // event flags.这个item是否取消了
    // for timer event management
    int   heapIndex; // index in timer min-heap.这个item在heap中的索引，对于定时器也会绑定一个event item.
    struct timeval timeout; // next timeout value.下面一个超时时间，绝对时间
    struct timeval period; // period value.周期触发时间
};

class IEventScheduler
{
  public:
    // schedule all active events
    // stored in pVecActiveList[size], actually size is MAX_EV_PRIORITY
    // call CReactor::ScheduleActiveEvent() to run an active event
    virtual void ScheduleActiveEvents(std::vector<DTEV_ITEM *> *pVecActiveList, int size) = 0;
  protected:
    CReactor *m_pReactor;
};

void CDefScheduler::ScheduleActiveEvents(std::vector<DTEV_ITEM *> *pVecActiveList, int size){
    // iterate all active lists and process based on scheduler
    for(int i = size-1; i >= 0; --i){ // 按照优先级下来
        if(!pVecActiveList[i].empty()){
            for(int n = 0; n < pVecActiveList[i].size(); ++n){ // 遍历Event然后交给Reactor来执行
                m_pReactor->ScheduleActiveEvent(pVecActiveList[i][n]); // 内部应该就是调用绑定的EventHandler的回调函数
            }
            pVecActiveList[i].clear();
        }
    }
}

#define ELE_SET_SIZE 4096
#define ELE_SET_SIZE_SHIFT 12
#define ELE_SET_ARRAY_NUM 256
class CDemuxTable
{
    struct ELE_SET
    {
        DTEV_ITEM *item_array;
    };
    ELE_SET m_pTable[ELE_SET_ARRAY_NUM];
};

class CSignalSet
{
  public:
    typedef std::map<IEventHandler*, DTEV_ITEM> SEH_MAP;
    typedef std::pair<IEventHandler*, DTEV_ITEM> SEH_PAIR;
    inline DTEV_ITEM *GetAt(IEventHandler *pHandler);
    inline int Insert(IEventHandler *pHandler);
    inline void Remove(IEventHandler *pHandler);
  private:
    SEH_MAP  m_mapHandlers;
};

class CSignalInfo
{
  public:
    int ProcessSignal();
  private:
    // 使用这个信号处理函数
    static void sig_handler(int signum);
#ifdef HAVE_SIGACTION
    struct sigaction* m_sigHandler_old[NSIG];
#else
    sighandler_t m_sigHandler_old[NSIG];
#endif
    std::list<DTEV_ITEM*> m_signalHandler[NSIG];
    sig_atomic_t  m_isigCaught[NSIG];
    HL_SOCKET m_socketPair[2]; // 这个是一个管道，通常这个方式可以通知其他线程信号触发了。
};

void CSignalInfo::sig_handler(int signum)
{
    //record occur counts of signum
    if(signum>=0 && signum<NSIG)
    {
        if(g_sigReactor != NULL)
        {
            CSignalInfo *sigInfo = g_sigReactor->GetSigInfo(); // 全局只有一个信号reactor.
            if(sigInfo != NULL)
            {
                sigInfo->m_isigCaught[signum]++; // 触发信号的话那么做一个标记
                char buf[2] = "s";
                send(sigInfo->m_socketPair[0], buf, 1, 0); // 向pipe里面写入内容，其他线程可以被通知到
            }
        }
    }
}