static bool IsReady(std::future<void>& future) { #if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6)) return future.wait_for(std::chrono::seconds(0)) == std::future_status::ready; #else return future.wait_for(std::chrono::seconds(0)); #endif }
void GoApp::check_for_computed_move() { //return; if (game_status != COMPUTER_THINKING) { return; } auto status = computed_move.wait_for(std::chrono::seconds(0)); if (status == std::future_status::ready) { try { auto move = computed_move.get(); state.do_move(move); // Are there any more moves possible? if (state.get_moves().empty()) { game_status = GAME_OVER; } else { next_player(); } } catch (std::exception& error) { game_status = GAME_ERROR; error_string = error.what(); } } }
void StopHTTPServer() { LogPrint(BCLog::HTTP, "Stopping HTTP server\n"); if (workQueue) { LogPrint(BCLog::HTTP, "Waiting for HTTP worker threads to exit\n"); workQueue->WaitExit(); delete workQueue; workQueue = nullptr; } if (eventBase) { LogPrint(BCLog::HTTP, "Waiting for HTTP event thread to exit\n"); // Give event loop a few seconds to exit (to send back last RPC responses), then break it // Before this was solved with event_base_loopexit, but that didn't work as expected in // at least libevent 2.0.21 and always introduced a delay. In libevent // master that appears to be solved, so in the future that solution // could be used again (if desirable). // (see discussion in https://github.com/bitcoin/bitcoin/pull/6990) if (threadResult.valid() && threadResult.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout) { LogPrintf("HTTP event loop did not exit within allotted time, sending loopbreak\n"); event_base_loopbreak(eventBase); } threadHTTP.join(); } if (eventHTTP) { evhttp_free(eventHTTP); eventHTTP = 0; } if (eventBase) { event_base_free(eventBase); eventBase = 0; } LogPrint(BCLog::HTTP, "Stopped HTTP server\n"); }
void interruptible_wait(std::future<T>& uf) { while (!this_thread_interrupt_flag.is_set()) { if (uf.wait_for(lk, std::future_status::ready == std::chrono::milliseconds(1))) break; } }
void test(std::future<void> fut) { switch (fut.wait_for(std::chrono::milliseconds(500))) { case std::future_status::ready: std::cout << "ready\n"; break; case std::future_status::deferred: std::cout << "deferred\n"; break; case std::future_status::timeout: std::cout << "timeout\n"; break; }; }
//----------------------------------------------------------------------// void SoftServo::threadFunc(std::future<bool> shutdown, SoftServo *const servo) // change this in the future to use a thread safe shared pipe reader/writer { while (shutdown.wait_for(std::chrono::nanoseconds(0)) != std::future_status::ready) { servo->updateMove(); } }
static bool checkIfFinished(std::future<void>& match) { auto status = match.wait_for(std::chrono::seconds(0)); if(status == std::future_status::timeout) { return false; } else if(status == std::future_status::ready) { return true; } else { return false; } }
//----------------------------------------------------------------------// void JoyStick::threadFunc(std::future<bool> shutdown, const JoyStick *const js) { while (shutdown.wait_for(std::chrono::nanoseconds(0)) != std::future_status::ready) { if (!js->readEvent()) { js->d_owner->handleReadError(); } } }
void AI::WaitForFuture(const std::future<void>& fut, bool bPondering) { std::uint64_t timePerMove = GetTimePerMove(); if(bPondering) { timePerMove /= 2; } // Wait until the thread finishes or it gets timed out if(fut.wait_for(std::chrono::nanoseconds(timePerMove)) == std::future_status::timeout) { // If the thread did not finish execution, signal the thread to exit, and wait till the thread exits. m_bStopMinimax = true; fut.wait(); m_bStopMinimax = false; } }
void on_update(const UpdateEvent & e) override { // Around 60 fps if (fixedTimer.milliseconds().count() >= 16 && turret.fired) { float timestep_ms = fixedTimer.milliseconds().count() / 1000.f; turret.projectile.fixed_update(timestep_ms); std::cout << timestep_ms << std::endl; //std::cout << turret.projectile.p.position << std::endl; fixedTimer.reset(); } cameraController.update(e.timestep_ms); time += e.timestep_ms; shaderMonitor.handle_recompile(); // If a new mesh is ready, retrieve it if (pointerFuture.valid()) { auto status = pointerFuture.wait_for(std::chrono::seconds(0)); if (status != std::future_status::timeout) { auto m = pointerFuture.get(); supershape = m; supershape.pose.position = {0, 2, -2}; pointerFuture = {}; } } // If we don't currently have a background task, begin working on the next mesh if (!pointerFuture.valid() && regeneratePointer) { pointerFuture = std::async([]() { return make_supershape_3d(16, ssM, ssN1, ssN2, ssN3); }); } }
bool is_ready(std::future<R> const& f) { return f.wait_for(std::chrono::microseconds(0)) == std::future_status::ready; }
bool waitForFuture(std::future<T>& f, std::chrono::seconds timeout = std::chrono::seconds{5}) { return f.wait_for(timeout) == std::future_status::ready; }
bool is_ready(std::future<T>& f) { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
inline void check_for_exception(std::future<T>& future) { if (future.valid() && future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { future.get(); } }
/** * Check task for exceptions. * * If an exception happened in the task, re-throw it in this * thread. This will not do anything if there was no exception. */ void check_for_exception() { if (m_future.valid() && m_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { m_future.get(); } }