Event::PollManager Class Reference

Event manager used in polling fashion. More...

Inheritance diagram for Event::PollManager:

Public Member Functions
virtual bool	IsThreaded ()
void	Run (bool)
bool	Poll (const timespec *when, bool immediate, pthread_mutex_t *mutex, pthread_cond_t *cond)
virtual void	Terminate (unsigned int millisecs)
virtual void	Blocking ()
virtual void	Unblocked ()
virtual bool	LongLived ()
virtual void	SetThreads (int, int)
virtual int	GetActiveLimit ()
virtual void	Queue (AsyncEvent *event, unsigned priority, bool nostart=false)
virtual void	QueueAt (AsyncEvent *event, const struct timespec *abstime)
virtual void	QueueAt (AsyncEvent *event, unsigned int millisec)
virtual void	Dequeue (AsyncEvent *event)
virtual void	QueueAtExit (AsyncEvent *event)
virtual const struct timespec *	NextEventDue ()

Static Public Member Functions
static Manager *	Create ()

Detailed Description

Event manager used in polling fashion.

Definition at line 25 of file PollManager.C.

Constructor & Destructor Documentation

PollManager()

Event::PollManager::PollManager

(

)

Definition at line 123 of file PollManager.C.

                              : _busy(false)
    {
        pthread_mutex_init (&_mutex, NULL);
        pthread_cond_init (&_cond, NULL);
 
        _mainQ   = new AsyncEventPriorityQueue;
        _timerQ  = new AsyncEventTimerQueue;
        _atExitQ = new AsyncEventPlainQueue;
 
        LOG_DEBUG (("PollManager created"));
    }

Member Function Documentation

Create()

Manager * Event::PollManager::Create ( )

static

Definition at line 135 of file PollManager.C.

                                  {
        if ( threadinstance != NULL )
            return threadinstance;
 
        threadinstance = new PollManager ();
 
        return threadinstance;
    }

IsThreaded()

virtual bool Event::PollManager::IsThreaded ( )

inlinevirtual

Definition at line 65 of file PollManager.C.

{ return false; }

Run()

void Event::PollManager::Run ( bool  )

inline

Definition at line 68 of file PollManager.C.

{}

Poll()

bool Event::PollManager::Poll	(	const timespec *	when,
		bool	immediate,
		pthread_mutex_t *	mutex,
		pthread_cond_t *	cond
	)

Definition at line 144 of file PollManager.C.

    {
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return false;
 
        // Unlock the client mutex for the duration of this call
        // So that stuff can be delivered to it via events
        if ( clientmutex ) pthread_mutex_unlock (clientmutex);
 
        // If the current thread is the busy thread, then recursing,
        // which is allowed.
        if ( _busy && !pthread_equal(_thread, pthread_self()) ) {
            // Someone else is executing the manager
            if ( !immediate ) {
                if ( when != 0 )
                    pthread_cond_timedwait (&_cond, &_mutex, when);
                else
                    pthread_cond_wait (&_cond, &_mutex);
            }
 
        } else {
 
            _busy = true;
            _thread = pthread_self();
 
            struct timespec now;
            getNow (now);
 
            if ( _timerQ->HasEvents () ) {
 
                AsyncEvent *tevent;
 
                // Get any due events onto the main event queue
                while ( (tevent = _timerQ->First (now)) != 0 ) {
                    LOG_DEBUG (("timerQ event %p due", tevent));
                    _mainQ->Insert (tevent, 0);
                }
            }
 
            _duetime = 0;
 
            const struct timespec *nextdue = _timerQ->NextPrio();
 
            if ( nextdue != 0 )
                _duetime = nextdue;
 
            if ( when != 0 ) {
                if ( _duetime == 0 || timespec_cmp (when, _duetime) )
                    _duetime = when;
            }
 
            LOG_DEBUG (("PollManager: events=%d",_mainQ->HasEvents()));
 
            if ( _mainQ->HasEvents() ) {
 
                AsyncEvent *event = _mainQ->First();
 
                Receiver *rcvr = event ? event->GetReceiver() : 0;
 
                // Client mutex is unlocked while events are delivered
                if ( rcvr != 0 ) {
                    // Queue event to receiver object prior to processing
                    // This avoids the race condition where the event
                    // object is being handled by one thread, and so cannot
                    // be cancelled, but another thread wants to delete it.
 
                    LOG_DEBUG (("Manager: queue %p", event));
                    rcvr->Queue (event);
 
                    pthread_mutex_unlock (&_mutex);
 
                    rcvr->Process ();
 
                } else {
 
                    pthread_mutex_unlock (&_mutex);
 
                    LOG_DEBUG (("Manager: deliver %p", event));
 
                    event->Deliver();
                }
 
                if ( pthread_mutex_lock(&_mutex) != 0 ) {
                    return false;
                }
 
            } else if ( _duetime != 0 ) {
                // Nothing to process until duetime, so wait
                (void) pthread_cond_timedwait (&_cond, &_mutex, _duetime);
            }
 
            _busy = false;
        }
 
        bool retval = ( _mainQ->HasEvents() &&
                        *(_mainQ->NextPrio()) < (unsigned) MAXPRIO );
 
        // Tell any other threads that something has happened
        pthread_cond_broadcast (&_cond);
 
        pthread_mutex_unlock (&_mutex);
 
        if ( clientmutex ) pthread_mutex_lock (clientmutex);
 
        return retval;
    }

Terminate()

void Event::PollManager::Terminate ( unsigned int  millisecs )

virtual

Definition at line 323 of file PollManager.C.

    {
        LOG_DEBUG (("Manager: Terminate in %dms", millisecs));
 
        struct timespec now;
 
        getNow (now);
 
        addMillisecs (now, millisecs);
 
        if ( pthread_mutex_lock (&_mutex) != 0 ) {
            pthread_exit(0);
        }
 
        // Cancel all queued events
        AsyncEvent    *event;
 
        while ( (event = _mainQ->First()) != 0 )
            _deQueue (event);
 
        while ( (event = _timerQ->First()) != 0 )
            _deQueue (event);
 
        // Deliver all at exit events
        // in the reverse order to their being added
        while ( (event = _atExitQ->Last()) != 0 ) {
            // Need to unlock during delivery
            pthread_mutex_unlock (&_mutex);
 
            event->Deliver ();
 
            if ( pthread_mutex_lock (&_mutex) != 0 ) {
                pthread_exit(0);
            }
        }
 
        pthread_mutex_unlock (&_mutex);
    }

Blocking()

virtual void Event::PollManager::Blocking ( )

inlinevirtual

Definition at line 80 of file PollManager.C.

{}

Unblocked()

virtual void Event::PollManager::Unblocked ( )

inlinevirtual

Definition at line 83 of file PollManager.C.

{}

LongLived()

virtual bool Event::PollManager::LongLived ( )

inlinevirtual

Definition at line 87 of file PollManager.C.

{ return false; }

SetThreads()

virtual void Event::PollManager::SetThreads ( int  , int    )

inlinevirtual

Definition at line 92 of file PollManager.C.

{}

GetActiveLimit()

virtual int Event::PollManager::GetActiveLimit ( )

inlinevirtual

Definition at line 95 of file PollManager.C.

{ return 0; }

Queue()

void Event::PollManager::Queue ( AsyncEvent *  event, unsigned  priority, bool  nostart = false  )

virtual

Definition at line 254 of file PollManager.C.

    {
        LOG_DEBUG (("Queue: %p prio=%u", event, priority));
 
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        _deQueue (event);
 
        _mainQ->Insert (event, priority);
 
        pthread_mutex_unlock (&_mutex);
 
    }

QueueAt()

void Event::PollManager::QueueAt ( AsyncEvent *  event, const struct timespec *  abstime  )

virtual

Definition at line 285 of file PollManager.C.

    {
        LOG_DEBUG (("Queue: %p @ %d.%9.9ld",
                    event, (int)duetime->tv_sec, duetime->tv_nsec));
 
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        _deQueue (event);
 
        _timerQ->Insert (event, *duetime);
 
        pthread_mutex_unlock (&_mutex);
    }

Dequeue()

void Event::PollManager::Dequeue ( AsyncEvent *  event )

virtual

Definition at line 313 of file PollManager.C.

    {
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        _deQueue (event);
 
        pthread_mutex_unlock (&_mutex);
    }

QueueAtExit()

void Event::PollManager::QueueAtExit ( AsyncEvent *  event )

virtual

Definition at line 271 of file PollManager.C.

    {
        LOG_DEBUG (("QueueAtExit: %p", event));
 
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        _deQueue (event);
 
        _atExitQ->Insert (event);
 
        pthread_mutex_unlock (&_mutex);
    }

NextEventDue()

virtual const struct timespec * Event::PollManager::NextEventDue ( )

inlinevirtual

Definition at line 118 of file PollManager.C.

{ return _duetime; }

---

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

• PollManager.C