#include <EventMultiplexer.h>

Inheritance diagram for core::EventMultiplexer:

Collaboration diagram for core::EventMultiplexer:

Classes
class	EventQueue

Public Types
enum	DISP_TYPE { RD = 0 , WR = 1 , EX = 2 }

Public Member Functions
	EventMultiplexer (DescriptorEventPublisher readDescriptorEventPublisher, DescriptorEventPublisher writeDescriptorEventPublisher, DescriptorEventPublisher *exceptionDescriptorEventPublisher)

virtual	~EventMultiplexer ()

	EventMultiplexer (const EventMultiplexer &)=delete

EventMultiplexer &	operator= (const EventMultiplexer &)=delete

DescriptorEventPublisher &	getDescriptorEventPublisher (DISP_TYPE dispType)

TimerEventPublisher &	getTimerEventPublisher ()

void	span (core::Event *event)

void	relax (core::Event *event)

void	signal (int sigNum)

void	terminate ()

void	clearEventQueue ()

TickStatus	tick (const utils::Timeval &tickTimeOut, const sigset_t &sigMask)

Protected Member Functions
int	maxFd ()

Protected Attributes
std::array< DescriptorEventPublisher *, 3 >	descriptorEventPublishers

Private Member Functions
TickStatus	waitForEvents (const utils::Timeval &tickTimeOut, const utils::Timeval &currentTime, const sigset_t &sigMask, int &activeDescriptorCount)

void	spanActiveEvents (const utils::Timeval &currentTime, int activeDescriptorCount)

void	executeEventQueue (const utils::Timeval &currentTime)

void	checkTimedOutEvents (const utils::Timeval &currentTime)

void	releaseExpiredResources (const utils::Timeval &currentTime)

utils::Timeval	getNextTimeout (const utils::Timeval &currentTime)

virtual void	spanActiveEvents (int activeDescriptorCount)=0

virtual int	monitorDescriptors (utils::Timeval &tickTimeOut, const sigset_t &sigMask)=0

int	observedEventReceiverCount ()

Private Attributes
core::TimerEventPublisher *const	timerEventPublisher

EventQueue	eventQueue

Detailed Description

Definition at line 46 of file EventMultiplexer.h.

Member Enumeration Documentation

◆ DISP_TYPE

enum core::EventMultiplexer::DISP_TYPE

Enumerator
RD
WR
EX

Definition at line 83 of file EventMultiplexer.h.

83{ RD = 0, WR = 1, EX = 2 };

core::EventMultiplexer::EX

@ EX

Definition EventMultiplexer.h:83

core::EventMultiplexer::WR

@ WR

Definition EventMultiplexer.h:83

core::EventMultiplexer::RD

@ RD

Definition EventMultiplexer.h:83

Constructor & Destructor Documentation

◆ EventMultiplexer() [1/2]

core::EventMultiplexer::EventMultiplexer	(	DescriptorEventPublisher *	readDescriptorEventPublisher,
		DescriptorEventPublisher *	writeDescriptorEventPublisher,
		DescriptorEventPublisher *	exceptionDescriptorEventPublisher )

Definition at line 41 of file EventMultiplexer.cpp.

        : descriptorEventPublishers{readDescriptorEventPublisher, writeDescriptorEventPublisher, exceptionDescriptorEventPublisher}
        , timerEventPublisher(new core::TimerEventPublisher()) {
    }

References EventMultiplexer().

Referenced by EventMultiplexer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~EventMultiplexer()

core::EventMultiplexer::~EventMultiplexer ( )

virtual

Reimplemented in core::multiplexer::epoll::EventMultiplexer, core::multiplexer::poll::EventMultiplexer, and core::multiplexer::select::EventMultiplexer.

Definition at line 48 of file EventMultiplexer.cpp.

                                        {
        for (DescriptorEventPublisher* descriptorEventPublisher : descriptorEventPublishers) {
            delete descriptorEventPublisher;
        }
        delete timerEventPublisher;
    }

References timerEventPublisher.

◆ EventMultiplexer() [2/2]

core::EventMultiplexer::EventMultiplexer ( const EventMultiplexer & )

delete

Member Function Documentation

◆ checkTimedOutEvents()

void core::EventMultiplexer::checkTimedOutEvents ( const utils::Timeval & currentTime )

private

Definition at line 144 of file EventMultiplexer.cpp.

                                                                              {
        for (DescriptorEventPublisher* const descriptorEventPublisher : descriptorEventPublishers) {
            descriptorEventPublisher->checkTimedOutEvents(currentTime);
        }
    }

Referenced by tick().

Here is the caller graph for this function:

◆ clearEventQueue()

void core::EventMultiplexer::clearEventQueue ( )

Definition at line 106 of file EventMultiplexer.cpp.

                                           {
        eventQueue.clear();
    }

◆ executeEventQueue()

void core::EventMultiplexer::executeEventQueue ( const utils::Timeval & currentTime )

private

Definition at line 140 of file EventMultiplexer.cpp.

                                                                            {
        eventQueue.execute(currentTime);
    }

Referenced by tick().

Here is the caller graph for this function:

◆ getDescriptorEventPublisher()

DescriptorEventPublisher & core::EventMultiplexer::getDescriptorEventPublisher ( DISP_TYPE dispType )

Definition at line 55 of file EventMultiplexer.cpp.

                                                                                              {
        return *descriptorEventPublishers[dispType];
    }

Referenced by core::eventreceiver::AcceptEventReceiver::AcceptEventReceiver(), core::eventreceiver::ConnectEventReceiver::ConnectEventReceiver(), core::eventreceiver::ExceptionalConditionEventReceiver::ExceptionalConditionEventReceiver(), core::eventreceiver::ReadEventReceiver::ReadEventReceiver(), and core::eventreceiver::WriteEventReceiver::WriteEventReceiver().

Here is the caller graph for this function:

◆ getNextTimeout()

utils::Timeval core::EventMultiplexer::getNextTimeout ( const utils::Timeval & currentTime )

private

Definition at line 158 of file EventMultiplexer.cpp.

                                                                                 {
        utils::Timeval nextTimeout = DescriptorEventReceiver::TIMEOUT::MAX;
 
        if (eventQueue.empty()) {
            for (const DescriptorEventPublisher* const descriptorEventPublisher : descriptorEventPublishers) {
                nextTimeout = std::min(descriptorEventPublisher->getNextTimeout(currentTime), nextTimeout);
            }
            nextTimeout = std::min(timerEventPublisher->getNextTimeout(currentTime), nextTimeout);
            nextTimeout = std::max(nextTimeout, utils::Timeval()); // In case nextTimeout is negative
        } else {
            nextTimeout = 0;
        }
 
        return nextTimeout;
    }

References core::TimerEventPublisher::getNextTimeout(), core::DescriptorEventReceiver::TIMEOUT::MAX, utils::Timeval::operator=(), timerEventPublisher, and utils::Timeval::Timeval().

Referenced by waitForEvents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTimerEventPublisher()

core::TimerEventPublisher & core::EventMultiplexer::getTimerEventPublisher ( )

Definition at line 59 of file EventMultiplexer.cpp.

                                                                      {
        return *timerEventPublisher;
    }

References timerEventPublisher.

◆ maxFd()

int core::EventMultiplexer::maxFd ( )

protected

Definition at line 183 of file EventMultiplexer.cpp.

                                {
        return std::accumulate(descriptorEventPublishers.begin(),
                               descriptorEventPublishers.end(),
                               -1,
                               [](int count, const DescriptorEventPublisher* descriptorEventPublisher) -> int {
                                   return std::max(descriptorEventPublisher->maxFd(), count);
                               });
    }

◆ monitorDescriptors()

virtual int core::EventMultiplexer::monitorDescriptors	(	utils::Timeval &	tickTimeOut,
		const sigset_t &	sigMask )

privatepure virtual

Implemented in core::multiplexer::epoll::EventMultiplexer, core::multiplexer::poll::EventMultiplexer, and core::multiplexer::select::EventMultiplexer.

Referenced by waitForEvents().

Here is the caller graph for this function:

◆ observedEventReceiverCount()

int core::EventMultiplexer::observedEventReceiverCount ( )

private

Definition at line 174 of file EventMultiplexer.cpp.

                                                     {
        return std::accumulate(descriptorEventPublishers.begin(),
                               descriptorEventPublishers.end(),
                               0,
                               [](int count, const DescriptorEventPublisher* descriptorEventPublisher) -> int {
                                   return count + descriptorEventPublisher->getObservedEventReceiverCount();
                               });
    }

◆ operator=()

EventMultiplexer & core::EventMultiplexer::operator= ( const EventMultiplexer & )

delete

◆ relax()

void core::EventMultiplexer::relax ( core::Event * event )

Definition at line 67 of file EventMultiplexer.cpp.

                                             {
        eventQueue.remove(event);
    }

Referenced by core::Event::relax().

Here is the caller graph for this function:

◆ releaseExpiredResources()

void core::EventMultiplexer::releaseExpiredResources ( const utils::Timeval & currentTime )

private

Definition at line 150 of file EventMultiplexer.cpp.

                                                                                  {
        for (DescriptorEventPublisher* const descriptorEventPublisher : descriptorEventPublishers) {
            descriptorEventPublisher->releaseDisabledEvents(currentTime);
        }
        timerEventPublisher->unobserveDisableEvents();
        DynamicLoader::execDlCloseDeleyed();
    }

References core::DynamicLoader::execDlCloseDeleyed(), timerEventPublisher, and core::TimerEventPublisher::unobserveDisableEvents().

Referenced by signal(), terminate(), and tick().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ signal()

void core::EventMultiplexer::signal ( int sigNum )

Definition at line 88 of file EventMultiplexer.cpp.

                                            {
        for (DescriptorEventPublisher* const descriptorEventPublisher : descriptorEventPublishers) {
            descriptorEventPublisher->signal(sigNum);
        }
        timerEventPublisher->stop();
 
        releaseExpiredResources(utils::Timeval::currentTime());
    }

References utils::Timeval::currentTime(), releaseExpiredResources(), core::TimerEventPublisher::stop(), and timerEventPublisher.

Here is the call graph for this function:

◆ span()

void core::EventMultiplexer::span ( core::Event * event )

Definition at line 63 of file EventMultiplexer.cpp.

                                            {
        eventQueue.insert(event);
    }

Referenced by core::Event::span().

Here is the caller graph for this function:

◆ spanActiveEvents() [1/2]

void core::EventMultiplexer::spanActiveEvents	(	const utils::Timeval &	currentTime,
		int	activeDescriptorCount )

private

Definition at line 135 of file EventMultiplexer.cpp.

                                                                                                      {
        timerEventPublisher->spanActiveEvents(currentTime);
        spanActiveEvents(activeDescriptorCount);
    }

References spanActiveEvents(), core::TimerEventPublisher::spanActiveEvents(), and timerEventPublisher.

Referenced by tick().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spanActiveEvents() [2/2]

virtual void core::EventMultiplexer::spanActiveEvents ( int activeDescriptorCount )

privatepure virtual

Implemented in core::multiplexer::epoll::EventMultiplexer, core::multiplexer::poll::EventMultiplexer, and core::multiplexer::select::EventMultiplexer.

Referenced by spanActiveEvents().

Here is the caller graph for this function:

◆ terminate()

void core::EventMultiplexer::terminate ( )

Definition at line 97 of file EventMultiplexer.cpp.

                                     {
        for (DescriptorEventPublisher* const descriptorEventPublisher : descriptorEventPublishers) {
            descriptorEventPublisher->disable();
        }
        timerEventPublisher->stop();
 
        releaseExpiredResources(utils::Timeval::currentTime());
    }

References utils::Timeval::currentTime(), releaseExpiredResources(), core::TimerEventPublisher::stop(), and timerEventPublisher.

Here is the call graph for this function:

◆ tick()

TickStatus core::EventMultiplexer::tick	(	const utils::Timeval &	tickTimeOut,
		const sigset_t &	sigMask )

Definition at line 71 of file EventMultiplexer.cpp.

                                                                                              {
        const utils::Timeval currentTime = utils::Timeval::currentTime();
 
        int activeDescriptorCount = 0;
 
        const TickStatus tickStatus = waitForEvents(tickTimeOut, currentTime, sigMask, activeDescriptorCount);
 
        if (tickStatus == TickStatus::SUCCESS) {
            spanActiveEvents(currentTime, activeDescriptorCount);
            executeEventQueue(currentTime);
            checkTimedOutEvents(currentTime);
            releaseExpiredResources(currentTime);
        }
 
        return tickStatus;
    }

References checkTimedOutEvents(), utils::Timeval::currentTime(), executeEventQueue(), releaseExpiredResources(), spanActiveEvents(), core::SUCCESS, and waitForEvents().

Here is the call graph for this function:

◆ waitForEvents()

TickStatus core::EventMultiplexer::waitForEvents	(	const utils::Timeval &	tickTimeOut,
		const utils::Timeval &	currentTime,
		const sigset_t &	sigMask,
		int &	activeDescriptorCount )

private

Definition at line 110 of file EventMultiplexer.cpp.

                                                                           {
        TickStatus tickStatus = TickStatus::SUCCESS;
 
        if (observedEventReceiverCount() > 0 || !timerEventPublisher->empty() || !eventQueue.empty()) {
            utils::Timeval nextTimeout = std::min(getNextTimeout(currentTime), tickTimeOut);
 
            activeDescriptorCount = monitorDescriptors(nextTimeout, sigMask);
 
            if (activeDescriptorCount < 0) {
                if (errno == EINTR) {
                    tickStatus = TickStatus::INTERRUPTED;
                } else {
                    tickStatus = TickStatus::TRACE;
                }
            }
        } else {
            tickStatus = TickStatus::NOOBSERVER;
        }
 
        return tickStatus;
    }

References getNextTimeout(), core::INTERRUPTED, monitorDescriptors(), core::NOOBSERVER, core::SUCCESS, and core::TRACE.

Referenced by tick().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ descriptorEventPublishers

std::array<DescriptorEventPublisher*, 3 > core::EventMultiplexer::descriptorEventPublishers

protected

Definition at line 117 of file EventMultiplexer.h.

◆ eventQueue

EventQueue core::EventMultiplexer::eventQueue

private

Definition at line 124 of file EventMultiplexer.h.

◆ timerEventPublisher

core::TimerEventPublisher* const core::EventMultiplexer::timerEventPublisher

private

Definition at line 122 of file EventMultiplexer.h.

Referenced by getNextTimeout(), getTimerEventPublisher(), releaseExpiredResources(), signal(), spanActiveEvents(), terminate(), and ~EventMultiplexer().

The documentation for this class was generated from the following files:

core/EventMultiplexer.h
core/EventMultiplexer.cpp

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DISP_TYPE

Constructor & Destructor Documentation

◆ EventMultiplexer() [1/2]

◆ ~EventMultiplexer()

◆ EventMultiplexer() [2/2]

Member Function Documentation

◆ checkTimedOutEvents()

◆ clearEventQueue()

◆ executeEventQueue()

◆ getDescriptorEventPublisher()

◆ getNextTimeout()

◆ getTimerEventPublisher()

◆ maxFd()

◆ monitorDescriptors()

◆ observedEventReceiverCount()

◆ operator=()

◆ relax()

◆ releaseExpiredResources()

◆ signal()

◆ span()

◆ spanActiveEvents() [1/2]

◆ spanActiveEvents() [2/2]

◆ terminate()

◆ tick()

◆ waitForEvents()

Member Data Documentation

◆ descriptorEventPublishers

◆ eventQueue

◆ timerEventPublisher