int InitiationDispatcher:: HandleEvents(Time_Value* timeout){ MpEvent::iterator it ; for(it = m_mpEvent.begin(); it!= m_mpEvent.end(); it++){ EventHandle* pEvent = it->first; pEvent->HandleEvents(it->second); } return 0; }
void ThreadPoolTaskExecutor::waitForEvent(const EventHandle& event) { invariant(event.isValid()); auto eventState = checked_cast<EventState*>(getEventFromHandle(event)); stdx::unique_lock<stdx::mutex> lk(_mutex); while (!eventState->isSignaledFlag) { eventState->isSignaledCondition.wait(lk); } }
void ThreadPoolTaskExecutor::signalEvent_inlock(const EventHandle& event) { invariant(event.isValid()); auto eventState = checked_cast<EventState*>(getEventFromHandle(event)); invariant(!eventState->isSignaledFlag); eventState->isSignaledFlag = true; eventState->isSignaledCondition.notify_all(); scheduleIntoPool_inlock(&eventState->waiters); _unsignaledEvents.erase(eventState->iter); }
void ReplicationExecutor::waitForEvent(const EventHandle& event) { boost::unique_lock<boost::mutex> lk(_mutex); invariant(event.isValid()); ++_totalEventWaiters; while ((event._generation == event._iter->generation) && !event._iter->isSignaled) { event._iter->isSignaledCondition->wait(lk); } --_totalEventWaiters; maybeNotifyShutdownComplete_inlock(); }
void testEventHandler() { EventHandler *handler = new EventHandler(); //handler->createEvent(&testObjectTOP, 0); EventHandle *handle1 = handler->createEvent(&testObjectMID, 2); handle1->setRecurrences(6); // "Times" to happen handle1->setPeriod(100); // period in milliseconds EventHandle *handle = handler->createEvent(&testObjectBOT, 1); handle->setRecurrences(3); handle->setPeriod(100); // add a single event EventHandle *handlex = handler->createEvent(&testObjectSingle, 0); handlex->setRecurrences(200); handlex->setPeriod(10); handlex->arg1 = (void*)"aaa"; // slower single event EventHandle *handlex2 = handler->createEvent(&testObjectSingle, 0); handlex2->setRecurrences(5); handlex2->setPeriod(1000); handlex2->arg1 = (void*)"bbb"; while(!handler->isEmpty()) { handler->handleEvents(); } }
// queue is only set for the top item void _doEvents(EventHandler* handler, PriorityQueue* handles, PriorityItem* item, bool threaded) { // handle left first, then handle right if(item == 0x0) return; debugLogEH("dE1"); // execute event if(item->data != 0x0) { EventHandle* handle = (EventHandle*)item->data; debugLogEH("dE2---xx"); if(!handle->handle()) { debugLogEH("dE3---" << handles->getSize()); handles->remove(item); debugLogEH("dE4"); } debugLogEH("dE5---xx"); } debugLogEH("dE6"); // go through the branches if(item->left != 0x0) { if(threaded){ handler->pool.enqueue(_doEvents, handler, handles, item->left, threaded); /*void (*f1)(EventHandler* handler, PriorityQueue* handles, PriorityItem* item, bool threaded); f1 = &_doEvents; handler->pool.enqueue([f1, handler, handles, item, threaded]{ return (*_doEvents)(handler, handles, item->left, threaded); }); //&_doEvents, handler, handles, item->left, threaded);*/ }else{ (*_doEvents)(handler, handles, item->left, threaded); } } if(item->right != 0x0) { if(threaded){ handler->pool.enqueue(_doEvents, handler, handles, item->right, threaded); }else{ _doEvents(handler, handles, item->right, threaded); } } }
StatusWith<ReplicationExecutor::CallbackHandle> ReplicationExecutor::onEvent( const EventHandle& event, const CallbackFn& work) { boost::lock_guard<boost::mutex> lk(_mutex); invariant(event.isValid()); invariant(event._generation <= event._iter->generation); WorkQueue* queue = &_readyQueue; if (event._generation == event._iter->generation && !event._iter->isSignaled) { queue = &event._iter->waiters; } else { queue = &_readyQueue; } return enqueueWork_inlock(queue, work); }
StatusWith<TaskExecutor::CallbackHandle> ThreadPoolTaskExecutor::onEvent(const EventHandle& event, const CallbackFn& work) { stdx::lock_guard<stdx::mutex> lk(_mutex); if (!event.isValid()) { return {ErrorCodes::BadValue, "Passed invalid event handle to onEvent"}; } auto eventState = checked_cast<EventState*>(getEventFromHandle(event)); auto cbHandle = enqueueCallbackState_inlock(&eventState->waiters, work); if (!cbHandle.isOK()) { return cbHandle; } if (eventState->isSignaledFlag) { scheduleIntoPool_inlock(&eventState->waiters); } return cbHandle; }