1 /* Copyright (c) 2007-2010, 2012-2015. The SimGrid Team.
2 * All rights reserved. */
4 /* This program is free software; you can redistribute it and/or modify it
5 * under the terms of the license (GNU LGPL) which comes with this package. */
7 #ifndef SIMGRID_SIMIX_HPP
8 #define SIMGRID_SIMIX_HPP
17 #include <type_traits>
19 #include <xbt/function_types.h>
20 #include <simgrid/simix.h>
22 XBT_PUBLIC(void) simcall_run_kernel(std::function<void()> const& code);
27 /** Fulfill a promise by executing a given code */
28 template<class R, class F>
29 void fulfill_promise(std::promise<R>& promise, F&& code)
32 promise.set_value(std::forward<F>(code)());
35 promise.set_exception(std::current_exception());
39 /** Fulfill a promise by executing a given code
41 * This is a special version for `std::promise<void>` because the default
42 * version does not compile in this case.
45 void fulfill_promise(std::promise<void>& promise, F&& code)
48 std::forward<F>(code)();
52 promise.set_exception(std::current_exception());
56 /** Execute some code in the kernel/maestro
58 * This can be used to enforce mutual exclusion with other simcall.
59 * More importantly, this enforces a deterministic/reproducible ordering
60 * of the operation with respect to other simcalls.
63 typename std::result_of<F()>::type kernel(F&& code)
65 // If we are in the maestro, we take the fast path and execute the
66 // code directly without simcall mashalling/unmarshalling/dispatch:
67 if (SIMIX_is_maestro())
68 return std::forward<F>(code)();
70 // If we are in the application, pass the code to the maestro which is
71 // executes it for us and reports the result. We use a std::future which
72 // conveniently handles the success/failure value for us.
73 typedef typename std::result_of<F()>::type R;
74 std::promise<R> promise;
75 simcall_run_kernel([&]{
76 xbt_assert(SIMIX_is_maestro(), "Not in maestro");
77 fulfill_promise(promise, std::forward<F>(code));
79 return promise.get_future().get();
89 args() : argc_(0), argv_(nullptr) {}
90 args(int argc, char** argv) : argc_(argc), argv_(argv) {}
95 for (int i = 0; i < this->argc_; i++)
99 this->argv_ = nullptr;
104 args(args const& that) = delete;
105 args& operator=(args const& that) = delete;
108 args(args&& that) : argc_(that.argc_), argv_(that.argv_)
111 that.argv_ = nullptr;
113 args& operator=(args&& that)
115 this->argc_ = that.argc_;
116 this->argv_ = that.argv_;
118 that.argv_ = nullptr;
122 int argc() const { return argc_; }
123 char** argv() { return argv_; }
124 const char*const* argv() const { return argv_; }
125 char* operator[](std::size_t i) { return argv_[i]; }
129 std::function<void()> wrap_main(xbt_main_func_t code, int argc, char **argv)
132 auto arg = std::make_shared<simgrid::simix::args>(argc, argv);
134 code(arg->argc(), arg->argv());
137 // TODO, we should free argv
138 else return std::function<void()>();
142 class ContextFactory;
144 XBT_PUBLIC_CLASS ContextFactory {
149 ContextFactory(std::string name) : name_(std::move(name)) {}
150 virtual ~ContextFactory();
151 virtual Context* create_context(std::function<void()> code,
152 void_pfn_smxprocess_t cleanup, smx_process_t process) = 0;
154 // Optional methods for attaching main() as a context:
156 /** Creates a context from the current context of execution
158 * This will not work on all implementation of `ContextFactory`.
160 virtual Context* attach(void_pfn_smxprocess_t cleanup_func, smx_process_t process);
161 virtual Context* create_maestro(std::function<void()> code, smx_process_t process);
163 virtual void run_all() = 0;
164 virtual Context* self();
165 std::string const& name() const
170 void declare_context(void* T, std::size_t size);
172 template<class T, class... Args>
173 T* new_context(Args&&... args)
175 T* context = new T(std::forward<Args>(args)...);
176 this->declare_context(context, sizeof(T));
181 XBT_PUBLIC_CLASS Context {
183 std::function<void()> code_;
184 void_pfn_smxprocess_t cleanup_func_ = nullptr;
185 smx_process_t process_ = nullptr;
189 Context(std::function<void()> code,
190 void_pfn_smxprocess_t cleanup_func,
191 smx_process_t process);
196 bool has_code() const
200 smx_process_t process()
202 return this->process_;
204 void set_cleanup(void_pfn_smxprocess_t cleanup)
206 cleanup_func_ = cleanup;
212 virtual void suspend() = 0;
215 XBT_PUBLIC_CLASS AttachContext : public Context {
218 AttachContext(std::function<void()> code,
219 void_pfn_smxprocess_t cleanup_func,
220 smx_process_t process)
221 : Context(std::move(code), cleanup_func, process)
226 /** Called by the context when it is ready to give control
229 virtual void attach_start() = 0;
231 /** Called by the context when it has finished its job */
232 virtual void attach_stop() = 0;
235 XBT_PUBLIC(void) set_maestro(std::function<void()> code);
236 XBT_PUBLIC(void) create_maestro(std::function<void()> code);