/usr/include/simgrid/simix.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 | /* Copyright (c) 2007-2010, 2012-2015. 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_HPP
#define SIMGRID_SIMIX_HPP
#include <cstddef>
#include <string>
#include <utility>
#include <memory>
#include <functional>
#include <xbt/function_types.h>
#include <xbt/future.hpp>
#include <xbt/functional.hpp>
#include <xbt/signal.hpp>
#include <simgrid/simix.h>
XBT_PUBLIC(void) simcall_run_kernel(std::function<void()> const& code);
/** Execute some code in the kernel and block
*
* run_blocking() is a generic blocking simcall. It is given a callback
* which is executed immediately in the SimGrid kernel. The callback is
* responsible for setting the suitable logic for waking up the process
* when needed.
*
* @ref simix::kernelSync() is a higher level wrapper for this.
*/
XBT_PUBLIC(void) simcall_run_blocking(std::function<void()> const& code);
template<class F> inline
void simcall_run_kernel(F& f)
{
simcall_run_kernel(std::function<void()>(std::ref(f)));
}
template<class F> inline
void simcall_run_blocking(F& f)
{
simcall_run_blocking(std::function<void()>(std::ref(f)));
}
namespace simgrid {
namespace simix {
/** Execute some code in the kernel/maestro
*
* This can be used to enforce mutual exclusion with other simcall.
* More importantly, this enforces a deterministic/reproducible ordering
* of the operation with respect to other simcalls.
*/
template<class F>
typename std::result_of<F()>::type kernelImmediate(F&& code)
{
// If we are in the maestro, we take the fast path and execute the
// code directly without simcall mashalling/unmarshalling/dispatch:
if (SIMIX_is_maestro())
return std::forward<F>(code)();
// If we are in the application, pass the code to the maestro which
// executes it for us and reports the result. We use a std::future which
// conveniently handles the success/failure value for us.
typedef typename std::result_of<F()>::type R;
simgrid::xbt::Result<R> result;
simcall_run_kernel([&]{
xbt_assert(SIMIX_is_maestro(), "Not in maestro");
simgrid::xbt::fulfillPromise(result, std::forward<F>(code));
});
return result.get();
}
XBT_PUBLIC(void) set_maestro(std::function<void()> code);
XBT_PUBLIC(void) create_maestro(std::function<void()> code);
// What's executed as SIMIX actor code:
typedef std::function<void()> ActorCode;
// Create ActorCode based on argv:
typedef std::function<ActorCode(std::vector<std::string> args)> ActorCodeFactory;
XBT_PUBLIC(void) registerFunction(const char* name, ActorCodeFactory factory);
/** These functions will be called when we detect a deadlock: any remaining process is locked on an action
*
* If these functions manage to unlock some of the processes, then the deadlock will be avoided.
*/
extern simgrid::xbt::signal<void()> onDeadlock;
}
}
/*
* Type of function that creates a process.
* The function must accept the following parameters:
* void* process: the process created will be stored there
* const char *name: a name for the object. It is for user-level information and can be NULL
* xbt_main_func_t code: is a function describing the behavior of the process
* void *data: data a pointer to any data one may want to attach to the new object.
* sg_host_t host: the location where the new process is executed
* int argc, char **argv: parameters passed to code
* xbt_dict_t pros: properties
*/
typedef smx_actor_t (*smx_creation_func_t) (
/* name */ const char*,
std::function<void()> code,
/* userdata */ void*,
/* hostname */ sg_host_t,
/* kill_time */ double,
/* props */ xbt_dict_t,
/* auto_restart */ int,
/* parent_process */ smx_actor_t);
extern "C"
XBT_PUBLIC(void) SIMIX_function_register_process_create(smx_creation_func_t function);
XBT_PUBLIC(smx_actor_t) simcall_process_create(const char *name,
std::function<void()> code,
void *data,
sg_host_t host,
double kill_time,
xbt_dict_t properties,
int auto_restart);
XBT_PUBLIC(smx_timer_t) SIMIX_timer_set(double date, simgrid::xbt::Task<void()> callback);
template<class F> inline
smx_timer_t SIMIX_timer_set(double date, F callback)
{
return SIMIX_timer_set(date, simgrid::xbt::Task<void()>(std::move(callback)));
}
template<class R, class T> inline
smx_timer_t SIMIX_timer_set(double date, R(*callback)(T*), T* arg)
{
return SIMIX_timer_set(date, [=](){ callback(arg); });
}
#endif
|