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
18 #include <type_traits>
20 #include <xbt/function_types.h>
21 #include <simgrid/simix.h>
23 XBT_PUBLIC(void) simcall_run_kernel(std::function<void()> const& code);
28 /** Fulfill a promise by executing a given code */
29 template<class R, class F>
30 void fulfill_promise(std::promise<R>& promise, F&& code)
33 promise.set_value(std::forward<F>(code)());
36 promise.set_exception(std::current_exception());
40 /** Fulfill a promise by executing a given code
42 * This is a special version for `std::promise<void>` because the default
43 * version does not compile in this case.
46 void fulfill_promise(std::promise<void>& promise, F&& code)
49 std::forward<F>(code)();
53 promise.set_exception(std::current_exception());
57 /** Execute some code in the kernel/maestro
59 * This can be used to enforce mutual exclusion with other simcall.
60 * More importantly, this enforces a deterministic/reproducible ordering
61 * of the operation with respect to other simcalls.
64 typename std::result_of<F()>::type kernel(F&& code)
66 // If we are in the maestro, we take the fast path and execute the
67 // code directly without simcall mashalling/unmarshalling/dispatch:
68 if (SIMIX_is_maestro())
69 return std::forward<F>(code)();
71 // If we are in the application, pass the code to the maestro which is
72 // executes it for us and reports the result. We use a std::future which
73 // conveniently handles the success/failure value for us.
74 typedef typename std::result_of<F()>::type R;
75 std::promise<R> promise;
76 simcall_run_kernel([&]{
77 xbt_assert(SIMIX_is_maestro(), "Not in maestro");
78 fulfill_promise(promise, std::forward<F>(code));
80 return promise.get_future().get();
90 args() : argc_(0), argv_(nullptr) {}
91 args(int argc, char** argv) : argc_(argc), argv_(argv) {}
96 for (int i = 0; i < this->argc_; i++)
100 this->argv_ = nullptr;
105 args(args const& that) = delete;
106 args& operator=(args const& that) = delete;
109 args(args&& that) : argc_(that.argc_), argv_(that.argv_)
112 that.argv_ = nullptr;
114 args& operator=(args&& that)
116 this->argc_ = that.argc_;
117 this->argv_ = that.argv_;
119 that.argv_ = nullptr;
123 int argc() const { return argc_; }
124 char** argv() { return argv_; }
125 const char*const* argv() const { return argv_; }
126 char* operator[](std::size_t i) { return argv_[i]; }
130 std::function<void()> wrap_main(xbt_main_func_t code, int argc, char **argv)
133 auto arg = std::make_shared<simgrid::simix::args>(argc, argv);
135 code(arg->argc(), arg->argv());
138 // TODO, we should free argv
139 else return std::function<void()>();
143 class ContextFactory;
145 XBT_PUBLIC_CLASS ContextFactory {
150 ContextFactory(std::string name) : name_(std::move(name)) {}
151 virtual ~ContextFactory();
152 virtual Context* create_context(std::function<void()> code,
153 void_pfn_smxprocess_t cleanup, smx_process_t process) = 0;
155 // Optional methods for attaching main() as a context:
157 /** Creates a context from the current context of execution
159 * This will not work on all implementation of `ContextFactory`.
161 virtual Context* attach(void_pfn_smxprocess_t cleanup_func, smx_process_t process);
162 virtual Context* create_maestro(std::function<void()> code, smx_process_t process);
164 virtual void run_all() = 0;
165 virtual Context* self();
166 std::string const& name() const
171 void declare_context(void* T, std::size_t size);
173 template<class T, class... Args>
174 T* new_context(Args&&... args)
176 T* context = new T(std::forward<Args>(args)...);
177 this->declare_context(context, sizeof(T));
182 XBT_PUBLIC_CLASS Context {
184 std::function<void()> code_;
185 void_pfn_smxprocess_t cleanup_func_ = nullptr;
186 smx_process_t process_ = nullptr;
190 Context(std::function<void()> code,
191 void_pfn_smxprocess_t cleanup_func,
192 smx_process_t process);
197 bool has_code() const
201 smx_process_t process()
203 return this->process_;
205 void set_cleanup(void_pfn_smxprocess_t cleanup)
207 cleanup_func_ = cleanup;
213 virtual void suspend() = 0;
216 XBT_PUBLIC_CLASS AttachContext : public Context {
219 AttachContext(std::function<void()> code,
220 void_pfn_smxprocess_t cleanup_func,
221 smx_process_t process)
222 : Context(std::move(code), cleanup_func, process)
227 /** Called by the context when it is ready to give control
230 virtual void attach_start() = 0;
232 /** Called by the context when it has finished its job */
233 virtual void attach_stop() = 0;
236 XBT_PUBLIC(void) set_maestro(std::function<void()> code);
237 XBT_PUBLIC(void) create_maestro(std::function<void()> code);