/usr/include/simgrid/simix/blocking_simcall.hpp is in libsimgrid-dev 3.14.159-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | /* Copyright (c) 2016. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
#ifndef SIMGRID_SIMIX_BLOCKING_SIMCALL_HPP
#define SIMGRID_SIMIX_BLOCKING_SIMCALL_HPP
#include <exception>
#include <functional>
#include <future>
#include <utility>
#include <xbt/sysdep.h>
#include <xbt/future.hpp>
#include <simgrid/kernel/future.hpp>
#include <simgrid/simix.h>
#include <simgrid/simix.hpp>
XBT_PUBLIC(void) simcall_run_blocking(std::function<void()> const& code);
namespace simgrid {
namespace simix {
XBT_PUBLIC(void) unblock(smx_actor_t process);
/** Execute some code in kernel mode and wakes up the actor when
* the result is available.
*
* It is given a callback which is executed in the SimGrid kernel and
* returns a `simgrid::kernel::Future<T>`. The kernel blocks the actor
* until the Future is ready and:
*
* - either returns the value wrapped in the future to the actor;
*
* - or raises the exception stored in the future in the actor.
*
* This can be used to implement blocking calls without adding new simcalls.
* One downside of this approach is that we don't have any semantic on what
* the actor is waiting. This might be a problem for the model-checker and
* we'll have to devise a way to make it work.
*
* @param code Kernel code returning a `simgrid::kernel::Future<T>`
* @return Value of the kernel future
* @exception Exception from the kernel future
*/
template<class F>
auto kernelSync(F code) -> decltype(code().get())
{
typedef decltype(code().get()) T;
if (SIMIX_is_maestro())
xbt_die("Can't execute blocking call in kernel mode");
smx_actor_t self = SIMIX_process_self();
simgrid::xbt::Result<T> result;
simcall_run_blocking([&result, self, &code]{
try {
auto future = code();
future.then_([&result, self](simgrid::kernel::Future<T> value) {
simgrid::xbt::setPromise(result, value);
simgrid::simix::unblock(self);
});
}
catch (...) {
result.set_exception(std::current_exception());
simgrid::simix::unblock(self);
}
});
return result.get();
}
/** A blocking (`wait()`-based) future for SIMIX processes */
// TODO, .wait_for()
// TODO, .wait_until()
// TODO, SharedFuture
// TODO, simgrid::simix::when_all - wait for all future to be ready (this one is simple!)
// TODO, simgrid::simix::when_any - wait for any future to be ready
template <class T>
class Future {
public:
Future() {}
Future(simgrid::kernel::Future<T> future) : future_(std::move(future)) {}
bool valid() const { return future_.valid(); }
T get()
{
if (!valid())
throw std::future_error(std::future_errc::no_state);
smx_actor_t self = SIMIX_process_self();
simgrid::xbt::Result<T> result;
simcall_run_blocking([this, &result, self]{
try {
// When the kernel future is ready...
this->future_.then_([this, &result, self](simgrid::kernel::Future<T> value) {
// ... wake up the process with the result of the kernel future.
simgrid::xbt::setPromise(result, value);
simgrid::simix::unblock(self);
});
}
catch (...) {
result.set_exception(std::current_exception());
simgrid::simix::unblock(self);
}
});
return result.get();
}
bool is_ready() const
{
if (!valid())
throw std::future_error(std::future_errc::no_state);
return future_.is_ready();
}
void wait()
{
// The future is ready! We don't have to wait:
if (this->is_ready())
return;
// The future is not ready. We have to delegate to the SimGrid kernel:
std::exception_ptr exception;
smx_actor_t self = SIMIX_process_self();
simcall_run_blocking([this, &exception, self]{
try {
// When the kernel future is ready...
this->future_.then_([this, self](simgrid::kernel::Future<T> value) {
// ...store it the simix kernel and wake up.
this->future_ = std::move(value);
simgrid::simix::unblock(self);
});
}
catch (...) {
exception = std::current_exception();
simgrid::simix::unblock(self);
}
});
}
private:
// We wrap an event-based kernel future:
simgrid::kernel::Future<T> future_;
};
/** Start some asynchronous work
*
* @param code SimGrid kernel code which returns a simgrid::kernel::Future
* @return Actor future
*/
template<class F>
auto kernelAsync(F code)
-> Future<decltype(code().get())>
{
typedef decltype(code().get()) T;
// Execute the code in the kernel and get the kernel future:
simgrid::kernel::Future<T> future =
simgrid::simix::kernelImmediate(std::move(code));
// Wrap the kernel future in a actor future:
return simgrid::simix::Future<T>(std::move(future));
}
}
}
#endif
|