static void* timer_event_thread_proc(void*) { for (;;) { int status; pthread_mutex_lock(&gTimerMutex); timespec spec = gTimeSpec; // mark our global to be zero // so we don't call timedwait again on a stale value gTimeSpec.tv_sec = 0; gTimeSpec.tv_nsec = 0; if (spec.tv_sec == 0 && spec.tv_nsec == 0) status = pthread_cond_wait(&gTimerCond, &gTimerMutex); else status = pthread_cond_timedwait(&gTimerCond, &gTimerMutex, &spec); if (status == 0) // someone signaled us with a new time { pthread_mutex_unlock(&gTimerMutex); } else { SkASSERT(status == ETIMEDOUT); // no need to unlock the mutex (its unlocked) // this is the payoff. Signal the event queue to wake up // and also check the delay-queue gEventQCondition.broadcast(); } } return 0; }
bool RawDumpCmdQueThread:: getCommand(sp<RawDumpCmdCookie> &rCmdCookie) { FUNCTION_IN; // bool ret = false; // Mutex::Autolock _l(mCmdMtx); // MY_LOGD("+ tid(%d), que size(%d)", ::gettid(), mCmdQ.size()); // while ( mCmdQ.empty() && ! exitPending() ) { mCmdCond.wait(mCmdMtx); } // get the latest frame, e.g. drop the if ( !mCmdQ.empty() ) { rCmdCookie = *mCmdQ.begin(); mCmdQ.erase(mCmdQ.begin()); ret = true; MY_LOGD(" frame[%d] in slot[%d] is dequeued.", rCmdCookie->getFrameCnt(),rCmdCookie->getFrameCnt() ); } // MY_LOGD("- tid(%d), que size(%d), ret(%d)", ::gettid(), mCmdQ.size(), ret); // FUNCTION_OUT; // return ret; }
//----------------------------------------------------------------------------- MBOOL CapBufMgrImp:: pushBuf(IImageBuffer* pImageBuffer, MBOOL const isFullSize) { Mutex::Autolock _l(mLock); // MY_LOGD("(%d),Buf(0x%08X),TS(%d.%06d)", isFullSize, (MUINT32)pImageBuffer, (MUINT32)((pImageBuffer->getTimestamp()/1000)/1000000), (MUINT32)((pImageBuffer->getTimestamp()/1000)%1000000)); // mlpImgBuf.push_back(pImageBuffer); if(pImageBuffer->getTimestamp() > 0) { mCond.signal(); } // if(!mbUse) { mbUse = MTRUE; } // return MTRUE; }
//----------------------------------------------------------------------------- MBOOL CapBufMgrImp:: enqueBuf(IImageBuffer* pImageBuffer, MBOOL const isFullSize) { Mutex::Autolock _l(mLock); // pImageBuffer->setTimestamp(0); // mlpImgBuf.push_back(pImageBuffer); if(mDequeBufCnt == 0) { MY_LOGE("mDequeBufCnt is 0"); } else { mDequeBufCnt--; } // mCondDequeBuf.signal(); // MY_LOGD("(%d),Buf(0x%08X),TS(%d.%06d),DBC(%d)", isFullSize, (MUINT32)pImageBuffer, (MUINT32)((pImageBuffer->getTimestamp()/1000)/1000000), (MUINT32)((pImageBuffer->getTimestamp()/1000)%1000000), mDequeBufCnt); // return MTRUE; }
//flushes current_, and leaves a new current in place, which might have some //data left over from the last one. void DestThreadedBufferPriv::bufswap() { ByteBuf * b = current_ ; current_ = NULL; ByteBufPtr prev = b ; { MutexGuard mg(lock_); if( puterr_ ) { PANICV( errbuf_.c_str()); } if( available_.empty()) { flush_.wait( mg ); } if( puterr_ ) { PANICV( errbuf_.c_str()); } if( available_.empty()) { PANICV( "no buffers available after flush"); } current_ = available_.front(); available_.pop_front(); } //put the unpushed portion of old current_ onto new one. current_->reset(); writeq_->push( prev.release()); }
void addJob(const blocking_job &job) { MutexGuard lock(&mutex_); queue_.push_back(job); cond_.notify(); }
int main() { SetConsoleTitle("Login server for Knight Online v" STRINGIFY(__VERSION)); #ifdef WIN32 // Override the console handler SetConsoleCtrlHandler(_ConsoleHandler, TRUE); #endif HookSignals(&s_hEvent); g_pMain = new LoginServer(); // Startup server if (g_pMain->Startup()) { printf("\nServer started up successfully!\n"); // Wait until console's signaled as closing s_hEvent.Wait(); } else { #ifdef WIN32 system("pause"); #endif } printf("Server shutting down, please wait...\n"); delete g_pMain; UnhookSignals(); return 0; }
void RemoteDisplayClient::onDisplayError(int32_t error) { ALOGI("onDisplayError error=%d", error); Mutex::Autolock autoLock(mLock); mDone = true; mCondition.broadcast(); }
/* Updates an attribute that meets the condition ...With its new value */ void Database::update(string rname, vector<string> attributes, vector<_Data> newvalues, Condition& c) { int indr = 0; for (indr = 0; indr < allRelations.size(); ++indr) { if (allRelations[indr].GetName() == rname) break; } _Relation r2 = *(c.evaluate(&allRelations[indr])); for (int i = 0; i < r2.Columns[0].Rows.size(); ++i) { for (int j = 0; j < allRelations[indr].Columns[0].Rows.size(); ++j) { bool upd = true; for (int k = 0; k < allRelations[indr].Columns.size(); ++i) { if (r2.Columns[k].Rows[i].Data != allRelations[indr].Columns[k].Rows[j].Data) { upd = false; break; } } if (upd == true) { for (int y = 0; y < attributes.size(); ++y) { for (int z = 0; z < allRelations[indr].Columns.size(); ++z) { if (attributes[y] == allRelations[indr].Columns[z].Name) { allRelations[indr].Columns[z].Rows[j] = newvalues[y]; } } } } } } }
bool ImageCreateThread:: getCommand(Command& rCmd) { bool ret = false; // Mutex::Autolock _lock(mCmdQueMtx); // MY_LOGD_IF(ENABLE_LOG_PER_FRAME, "+ que size(%d)", mCmdQue.size()); // // Wait until the queue is not empty or this thread will exit. while ( mCmdQue.empty() && ! exitPending() ) { status_t status = mCmdQueCond.wait(mCmdQueMtx); if ( NO_ERROR != status ) { MY_LOGW("wait status(%d), que size(%d), exitPending(%d)", status, mCmdQue.size(), exitPending()); } } // if ( ! mCmdQue.empty() ) { // If the queue is not empty, take the first command from the queue. ret = true; rCmd = *mCmdQue.begin(); mCmdQue.erase(mCmdQue.begin()); MY_LOGD("command:%s", rCmd.name()); } // MY_LOGD_IF(ENABLE_LOG_PER_FRAME, "- que size(%d), ret(%d)", mCmdQue.size(), ret); return ret; }
void DatabaseThread::AddRequest(Packet * pkt) { _lock.Acquire(); _queue.push(pkt); _lock.Release(); s_hEvent.Signal(); }
void RemoteDisplayClient::onDisplayDisconnected() { ALOGI("onDisplayDisconnected"); Mutex::Autolock autoLock(mLock); mDone = true; mCondition.broadcast(); }
void gridStartIterateFiltered(int32_t x, int32_t y, uint32_t radius, PointTree::Filter *filter, Condition const &condition) { if (filter == NULL) { gridPointTree->query(x, y, radius); } else { gridPointTree->query(*filter, x, y, radius); } PointTree::ResultVector::iterator w = gridPointTree->lastQueryResults.begin(), i; for (i = w; i != gridPointTree->lastQueryResults.end(); ++i) { BASE_OBJECT *obj = static_cast<BASE_OBJECT *>(*i); if (!condition.test(obj)) // Check if we should skip this object. { filter->erase(gridPointTree->lastFilteredQueryIndices[i - gridPointTree->lastQueryResults.begin()]); // Stop the object from appearing in future searches. } else if (isInRadius(obj->pos.x - x, obj->pos.y - y, radius)) // Check that search result is less than radius (since they can be up to a factor of sqrt(2) more). { *w = *i; ++w; } } gridPointTree->lastQueryResults.erase(w, i); // Erase all points that were a bit too far. gridPointTree->lastQueryResults.push_back(NULL); // NULL-terminate the result. gridIterator = &gridPointTree->lastQueryResults[0]; /* // In case you are curious. debug(LOG_WARNING, "gridStartIterateFiltered(%d, %d, %u) found %u objects", x, y, radius, (unsigned)gridPointTree->lastQueryResults.size() - 1); */ }
status_t MSurface::registerBuffers(const BufferHeap& buffers) { INFO(__func__); Mutex::Autolock _l(mLock); ++registerBuffersCount; mCond.signal(); return NO_ERROR; }
bool Combat::CombatConditionFunc(Creature* caster, Creature* target, const CombatParams& params, void*) { bool result = false; for (const Condition* condition : params.conditionList) { if (caster == target || !target->isImmune(condition->getType())) { Condition* conditionCopy = condition->clone(); if (caster) { conditionCopy->setParam(CONDITIONPARAM_OWNER, caster->getID()); } //TODO: infight condition until all aggressive conditions has ended result = target->addCombatCondition(conditionCopy); } } return result; }
void MagicField::onStepInField(Creature* creature) { //remove magic walls/wild growth if(id == ITEM_MAGICWALL || id == ITEM_WILDGROWTH || id == ITEM_MAGICWALL_SAFE || id == ITEM_WILDGROWTH_SAFE || isBlocking()) { if(!creature->isInGhostMode()) g_game.internalRemoveItem(this, 1); return; } const ItemType& it = items[getID()]; if(it.condition) { Condition* conditionCopy = it.condition->clone(); uint32_t ownerId = getOwner(); if(ownerId) { bool harmfulField = true; if(g_game.getWorldType() == WORLD_TYPE_NO_PVP || getTile()->hasFlag(TILESTATE_NOPVPZONE)) { Creature* owner = g_game.getCreatureByID(ownerId); if(owner) { if(owner->getPlayer() || (owner->isSummon() && owner->getMaster()->getPlayer())) harmfulField = false; } } Player* targetPlayer = creature->getPlayer(); if(targetPlayer) { Player* attackerPlayer = g_game.getPlayerByID(ownerId); if(attackerPlayer) { if(Combat::isProtected(attackerPlayer, targetPlayer)) harmfulField = false; } } if(!harmfulField || (OTSYS_TIME() - createTime <= 5000) || creature->hasBeenAttacked(ownerId)) conditionCopy->setParam(CONDITIONPARAM_OWNER, ownerId); } creature->addCondition(conditionCopy); } }
ssize_t Socket_Impl:: size_ (ACE_Time_Value const* timeout) { ACE_Time_Value abs_time; if (timeout) abs_time = ACE_OS::gettimeofday () + *timeout; Lock l (mutex_); while (queue_.is_empty ()) { if (timeout) { if (cond_.wait (&abs_time) != -1) break; } else { if (cond_.wait () != -1) break; } return -1; // errno is already set } // I can't get the head of the queue without actually dequeuing // the element. // Message_ptr m; if (queue_.dequeue_head (m) == -1) ACE_OS::abort (); if (queue_.enqueue_head (m) == -1) ACE_OS::abort (); if (m->find (NoData::id) != 0) { errno = ENOENT; return -1; } Data const* d = static_cast<Data const*>(m->find (Data::id)); return static_cast<ssize_t> (d->size ()); }
void operator()(void) { for(int i = 0; i < numThreads; ++i) { sleep(1); waitSignal.wakeAll(); } }
void Creature::executeConditions(uint32_t interval) { for(ConditionList::iterator it = conditions.begin(); it != conditions.end();){ if(!(*it)->onTick(this, interval)){ Condition* condition = *it; onEndCondition(condition); it = conditions.erase(it); condition->onEnd(this, CONDITIONEND_DURATION); onEndCondition(condition, false); delete condition; } else{ ++it; } } }
void Creature::removeCondition(MechanicType type) { for(ConditionList::iterator it = conditions.begin(); it != conditions.end();){ if((*it)->getMechanicType() == type){ Condition* condition = *it; onEndCondition(condition); it = conditions.erase(it); condition->onEnd(this, CONDITIONEND_REMOVED); onEndCondition(condition, false); delete condition; } else{ ++it; } } }
void Creature::removeCondition(const std::string& name, uint32_t sourceId) { for(ConditionList::iterator it = conditions.begin(); it != conditions.end();){ if((*it)->getName() == name && (*it)->getSourceId() == sourceId){ Condition* condition = *it; onEndCondition(condition); it = conditions.erase(it); condition->onEnd(this, CONDITIONEND_REMOVED); onEndCondition(condition, false); delete condition; } else{ ++it; } } }
void * pthread_func(void* p){ mutex.lock(); cout<<"this is child thread"<<endl; cond.wait(); cout<<"waking"<<endl; mutex.unlock(); pthread_exit(NULL); }
ThreadReturnType PEGASUS_THREAD_CDECL deq(void * parm) { Thread* my_thread = (Thread *)parm; parmdef * Parm = (parmdef *)my_thread->get_parm(); MessageType type; int first = Parm->first; int second = Parm->second; int count = Parm->count; Condition * condstart = Parm->cond_start; MessageQueue * mq = Parm->mq; condstart->signal(); Message * message; type = 0; while (type != CLOSE_CONNECTION_MESSAGE) { message = mq->dequeue(); while (!message) { message = mq->dequeue(); } type = message->getType(); delete message; } if (verbose) { #if defined (PEGASUS_OS_VMS) // // Threads::self returns long-long-unsigned. // printf("Received Cancel Message, %llu about to end\n", Threads::self()); #else cout << "Received Cancel Message, " << Threads::self() << " about to end\n"; #endif } return ThreadReturnType(0); }
void Creature::removeConditions(ConditionEnd_t reason, bool onlyPersistent/* = true*/) { for(ConditionList::iterator it = conditions.begin(); it != conditions.end(); ) { if(onlyPersistent && !(*it)->isPersistent()) { ++it; continue; } Condition* condition = *it; it = conditions.erase(it); condition->endCondition(this, reason); onEndCondition(condition->getType()); delete condition; } }
std::cv_status wait_for(Condition& cv, Lock& lock, const std::chrono::duration<Rep, Period>& duration, const cancellation_token& token) { using handler_type = detail::cv_cancellation_handler<Condition, Lock>; handler_type handler(cv, lock); detail::cv_cancellation_guard<handler_type> guard(token, handler); if (guard.is_cancelled()) return std::cv_status::no_timeout; return cv.wait_for(lock, duration); }
void wait(Condition& cv, Lock& lock, const cancellation_token& token) { using handler_type = detail::cv_cancellation_handler<Condition, Lock>; handler_type handler(cv, lock); detail::cv_cancellation_guard<handler_type> guard(token, handler); if (guard.is_cancelled()) return; cv.wait(lock); }
std::cv_status wait_until(Condition& cv, Lock& lock, const std::chrono::time_point<Clock, Duration>& time_point, const cancellation_token& token) { using handler_type = detail::cv_cancellation_handler<Condition, Lock>; handler_type handler(cv, lock); detail::cv_cancellation_guard<handler_type> guard(token, handler); if (guard.is_cancelled()) return std::cv_status::no_timeout; return cv.wait_until(lock, time_point); }
void Creature::executeConditions(uint32_t interval) { for(ConditionList::iterator it = conditions.begin(); it != conditions.end(); ) { if((*it)->executeCondition(this, interval)) { ++it; continue; } Condition* condition = *it; it = conditions.erase(it); condition->endCondition(this, CONDITIONEND_TICKS); onEndCondition(condition->getType()); delete condition; } }
std::vector<T> list(const Condition & condition) { std::vector<T> lst; for (;hasNext(); next()) { if (condition.test(&get())) { lst.push_back(get()); } } return lst; }
void Creature::removeCondition(ConditionType_t type, ConditionId_t id) { for(ConditionList::iterator it = conditions.begin(); it != conditions.end(); ) { if((*it)->getType() != type || (*it)->getId() != id) { ++it; continue; } Condition* condition = *it; it = conditions.erase(it); condition->endCondition(this, CONDITIONEND_ABORT); onEndCondition(condition->getType()); delete condition; } }