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();
}
}
