inline void setState(qi::Atomic<int>& state, TaskState from, TaskState to, TaskState from2, TaskState to2) { for (unsigned i=0; i<1000; ++i) if (state.setIfEquals(from, to) || state.setIfEquals(from2, to2)) return; while (true) { for (unsigned i=0; i<1000; ++i) { if (state.setIfEquals(from, to) || state.setIfEquals(from2, to2)) return; qi::os::msleep(1); // TODO: 1ms is probably too long } qiLogWarning() << "PeriodicTask is stuck " << from << ' ' << to << ' ' << from2 << ' ' << to2 << ' '<< *state; } }
void PeriodicTaskPrivate::_reschedule(qi::int64_t delay) { qiLogDebug() << _name <<" rescheduling in " << delay; _task = getEventLoop()->async(boost::bind(&PeriodicTaskPrivate::_wrap, shared_from_this()), delay); if (!_state.setIfEquals(Task_Rescheduling, Task_Scheduled)) qiLogError() << "PeriodicTask forbidden state change while rescheduling " << *_state; }
qi::Future<void> TestImpl::saySlowerButBetter(const std::string& mess) { qiLogInfo() << "Saying " << mess << " slowly"; assert(!_boole.swap(true)); qi::sleepFor(qi::Seconds(1)); ++_numberOfSay; message.set(mess); onSayMessage(_numberOfSay); qiLogInfo() << "Middle say"; assert(_boole.swap(false)); return qi::asyncDelay([]{ qiLogInfo() << "End say"; }, qi::Seconds(1)); }
void PeriodicTaskPrivate::_trigger(qi::Future<void> future) { // if future was not canceled, the task already ran, don't retrigger if (!future.isCanceled()) return; // else, start the task now if we are still triggering if (_state.setIfEquals(Task_Triggering, Task_Rescheduling)) _reschedule(0); }
void Application::stop() { static qi::Atomic<bool> atStopHandlerCall = false; if (atStopHandlerCall.setIfEquals(false, true)) { FunctionList& fl = lazyGet(globalAtStop); qiLogDebug() << "Executing " << fl.size() << " atStop handlers"; for (FunctionList::iterator i = fl.begin(); i!= fl.end(); ++i) { try { (*i)(); } catch (std::exception& e) { qiLogError() << "Application atStop callback throw the following error: " << e.what(); } } globalIsStop = true; globalCond.notify_all(); } }
void PeriodicTaskPrivate::_wrap() { if (*_state == Task_Stopped) qiLogError() << "PeriodicTask inconsistency: stopped from callback"; /* To avoid being stuck because of unhandled transition, the rule is * that any other thread playing with our state can only do so * to stop us, and must eventualy reach the Stopping state */ if (_state.setIfEquals(Task_Stopping, Task_Stopped)) return; /* reschedule() needs to call async() before reseting state from rescheduling * to scheduled, to protect the _task object. So we might still be * in rescheduling state here. */ while (*_state == Task_Rescheduling) boost::this_thread::yield(); // order matters! check scheduled state first as the state cannot change // from triggering to scheduled but can change in the other way if (!_state.setIfEquals(Task_Scheduled, Task_Running) && !_state.setIfEquals(Task_Triggering, Task_Running)) { setState(_state, Task_Stopping, Task_Stopped); return; } bool shouldAbort = false; qi::int64_t wall = 0, now=0, delta=0; qi::int64_t usr, sys; bool compensate = _compensateCallTime; // we don't want that bool to change in the middle try { wall = qi::os::ustime(); std::pair<qi::int64_t, qi::int64_t> cpu = qi::os::cputime(); _tid = os::gettid(); _callback(); _tid = invalidThreadId; now = qi::os::ustime(); wall = now - wall; std::pair<qi::int64_t, qi::int64_t> cpu2 = qi::os::cputime(); usr = cpu2.first - cpu.first; sys = cpu2.second - cpu.second; if (compensate) delta = wall; } catch (const std::exception& e) { qiLogInfo() << "Exception in task " << _name << ": " << e.what(); shouldAbort = true; } catch(...) { qiLogInfo() << "Unknown exception in task callback."; shouldAbort = true; } if (shouldAbort) { setState(_state, Task_Stopping, Task_Stopped, Task_Running, Task_Stopped); return; } else { _callStats.push((float)wall / 1e6f, (float)usr / 1e6f, (float)sys / 1e6f); if (now - _statsDisplayTime >= 20000000) { float secTime = float(now - _statsDisplayTime) / 1e6f; _statsDisplayTime = now; unsigned int count = _callStats.count(); std::string catName = "stats." + _name; qiLogVerbose(catName.c_str()) << (_callStats.user().cumulatedValue() * 100.0 / secTime) << "% " << count << " " << _callStats.wall().asString(count) << " " << _callStats.user().asString(count) << " " << _callStats.system().asString(count) ; _callStats.reset(); } if (!_state.setIfEquals(Task_Running, Task_Rescheduling)) { // If we are not in running state anymore, someone switched us // to stopping setState(_state, Task_Stopping, Task_Stopped); return; } _reschedule(std::max((qi::int64_t)0, _usPeriod - delta)); } }