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");
}
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
}
/**
* Close the task. This will raise in this thread any exception the
* task generated in the other thread. Calling this function is
* optional, because the destructor will also call this function.
* But because it can throw an exception, it is better to call it
* explicitly.
*/
void close() {
// If an exception happened in the task, re-throw
// it in this thread. This will block if the task
// isn't finished.
if (m_future.valid()) {
m_future.get();
}
// Make sure task is done.
if (m_thread.joinable()) {
m_thread.join();
}
}
void handleFuture( std::future< _2Real::BlockResult > &obj, std::string const& info = "" )
{
obj.wait();
_2Real::BlockResult val = obj.get();
switch ( val )
{
case _2Real::BlockResult::CARRIED_OUT:
std::cout << "---- " << info << " was carried out" << std::endl;
break;
case _2Real::BlockResult::IGNORED:
std::cout << "---- " << info << " was ignored" << std::endl;
break;
}
}
std::pair<long double, int> getResult(
std::chrono::system_clock::time_point deadline, int maxPrecision)
{
long double result = 1;
int precision = 1;
if (std::chrono::system_clock::now() < deadline) {
while (precision < maxPrecision) {
const int nextPrecision = std::min(maxPrecision, precision * 2);
future = std::async(std::launch::async, compute, nextPrecision);
if (future.wait_until(deadline) == std::future_status::timeout)
break;
result = future.get();
precision = nextPrecision;
}
}
return { result, precision };
}
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 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;
}
}
int factorial1(std::future<int>& f)
{
int n = f.get();
int result = 1;
for (int i = 1; i <= n; ++i)
result *= i;
return result;
}
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();
}
}
/**
* Get the header data from the file.
*
* @returns Header.
* @throws Some form of osmium::io_error if there is an error.
*/
osmium::io::Header header() {
if (m_status == status::error) {
throw io_error("Can not get header from reader when in status 'error'");
}
try {
if (m_header_future.valid()) {
m_header = m_header_future.get();
if (m_read_which_entities == osmium::osm_entity_bits::nothing) {
m_status = status::eof;
}
}
} catch (...) {
close();
m_status = status::error;
throw;
}
return m_header;
}
void C4Network2UPnPP::ClearMappings()
{
action = std::async([this, action = std::move(action)]() {
action.wait();
for (auto mapping : added_mappings)
RemovePortMapping(mapping);
added_mappings.clear();
});
}
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 C4Network2UPnPP::AddMapping(C4Network2IOProtocol protocol, uint16_t intport, uint16_t extport)
{
PortMapping mapping;
mapping.external_port = extport;
mapping.internal_port = intport;
mapping.protocol = (protocol == P_TCP ? "TCP" : "UDP");
added_mappings.push_back(mapping);
action = std::async([this, action = std::move(action), mapping]() {
action.wait();
AddPortMapping(mapping);
});
}
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);
});
}
}
//========================================================================
void CSirServer::NotifyResult(CLIENT* client, std::future<SCRESULT>& result)
{
SCRESULT rc = result.get();
stringstream ss;
switch (rc)
{
case SCR_SUCCESS:
ss << "OK";
break;
case SCR_TIMEOUT:
ss << "TIMEOUT";
break;
default:
ss << "ERROR";
break;
}
ss << std::endl;
Notify(client, ss.str());
}
TEST_F(DBusConnectionTest, LibdbusConnectionsMayCommitSuicide) {
const ::DBusBusType libdbusType = ::DBusBusType::DBUS_BUS_SESSION;
::DBusError libdbusError;
dbus_error_init(&libdbusError);
::DBusConnection* libdbusConnection = dbus_bus_get_private(libdbusType, &libdbusError);
assert(libdbusConnection);
dbus_connection_set_exit_on_disconnect(libdbusConnection, false);
auto dispatchThread = std::thread(&dispatch, libdbusConnection);
::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"ListNames");
dbus_message_set_signature(libdbusMessageCall, "");
DBusPendingCall* libdbusPendingCall;
dbus_connection_send_with_reply(
libdbusConnection,
libdbusMessageCall,
&libdbusPendingCall,
500);
dbus_pending_call_set_notify(
libdbusPendingCall,
notifyThunk,
libdbusConnection,
NULL);
ASSERT_EQ(true, future.get());
dispatchThread.join();
}
bool is_ready(std::future<R> const& f) {
return f.wait_for(std::chrono::microseconds(0)) == std::future_status::ready;
}
void schedule(std::weak_ptr<Mailbox>) final {
promise.set_value();
future.wait();
std::this_thread::sleep_for(1ms);
waited = true;
}
void wait() {
promise.set_value();
future.wait();
std::this_thread::sleep_for(1ms);
waited = true;
}
#include <boost/asio/use_future.hpp>
#include <boost/asio/yield.hpp>
#include <vector>
#include <array>
namespace bp = boost::process;
BOOST_AUTO_TEST_CASE(future, *boost::unit_test::timeout(15))
{
using boost::unit_test::framework::master_test_suite;
boost::asio::io_context ios;
std::future<int> fut = bp::async_system(
ios, boost::asio::use_future,
master_test_suite().argv[1],
"test", "--exit-code", "42");
ios.run();
int exit_code = 0;
BOOST_CHECK_NO_THROW(exit_code = fut.get());
BOOST_CHECK_EQUAL(exit_code, 42);
}
BOOST_AUTO_TEST_CASE(future_error, *boost::unit_test::timeout(15))
{
using boost::unit_test::framework::master_test_suite;
boost::asio::io_context ios;
// return from thread
int getNum2(std::future<int> &f) {
print("In getNum1");
return f.get() + 10;
}
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;
}
void thread_pool::handle_task(std::future<void> f) {
f.get();
}
void s(std::future<double>& fut)
{
double x = fut.get();
std::cout << " fut = " << x << std::endl;
}
void hook_post_step()
{
parent_t::hook_post_step(); // includes output
this->mem->barrier();
if (this->rank == 0)
{
// assuring previous async step finished ...
#if defined(STD_FUTURE_WORKS)
if (
params.async &&
this->timestep != 0 && // ... but not in first timestep ...
((this->timestep - 1) % this->outfreq != 0) // ... and not after diag call
//!((this->timestep-1) == 0 || ((this->timestep-1) % this->outfreq == 0 && (this->timestep-1) >= this->spinup)) // .. and not after diag
) {
assert(ftr.valid());
ftr.get();
} else assert(!ftr.valid());
#endif
// running synchronous stuff
prtcls->step_sync(
params.cloudph_opts,
make_arrinfo(this->mem->advectee(ix::th)),
make_arrinfo(this->mem->advectee(ix::rv))
);
// running asynchronous stuff
{
using libcloudphxx::lgrngn::particles_t;
using libcloudphxx::lgrngn::CUDA;
using libcloudphxx::lgrngn::multi_CUDA;
#if defined(STD_FUTURE_WORKS)
if (params.async)
{
assert(!ftr.valid());
if(params.backend == multi_CUDA)
ftr = std::async(
std::launch::async,
&particles_t<real_t, multi_CUDA>::step_async,
dynamic_cast<particles_t<real_t, multi_CUDA>*>(prtcls.get()),
params.cloudph_opts
);
else if(params.backend == CUDA)
ftr = std::async(
std::launch::async,
&particles_t<real_t, CUDA>::step_async,
dynamic_cast<particles_t<real_t, CUDA>*>(prtcls.get()),
params.cloudph_opts
);
assert(ftr.valid());
} else
#endif
prtcls->step_async(params.cloudph_opts);
}
// performing diagnostics
//if (this->timestep == 0 || (this->timestep % this->outfreq == 0 && this->timestep >= this->spinup))
if (this->timestep % this->outfreq == 0)
{
#if defined(STD_FUTURE_WORKS)
if (params.async)
{
assert(ftr.valid());
ftr.get();
}
#endif
diag();
}
}
this->mem->barrier();
}
void helper(std::future<void>& task, ray_tracing::Semaphore& semaphore)
{
task.get();
semaphore.increase();
}
