# Use the PREDEFINED tag if you want to use a different macro definition that
# overrules the definition found in the source code.
-EXPAND_AS_DEFINED =
+EXPAND_AS_DEFINED = COLL_APPLY COLL_GATHERS COLL_ALLGATHERS COLL_ALLGATHERVS COLL_ALLREDUCES COLL_ALLTOALLS \
+ COLL_ALLTOALLVS COLL_BCASTS COLL_REDUCES COLL_REDUCE_SCATTERS COLL_SCATTERS COLL_BARRIERS
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all references to function-like macros
etc.
-\subsubsection pf_peer \<peer\> (Vivaldi netzones only)
+\subsubsection pf_peer <peer> (Vivaldi netzones only)
This tag represents a peer, as in Peer-to-Peer (P2P) networks. This
can only be used in Vivaldi NetZones. It creates the following
If you installed SimGrid to a non-standard path, you may have to
specify the full path to simgrid-colorizer on the above line, such as
\c /opt/simgrid/bin/simgrid-colorizer. If you did not install it at all,
-you can find it in <simgrid_root_directory>/bin/colorize.
+you can find it in \<simgrid_root_directory\>/bin/colorize.
For a classical Gantt-Chart visualization, you can produce a [Paje][fn:5] trace:
- <b>Kill actors</b>.
@ref examples/s4u/actor-kill/s4u-actor-kill.cpp \n
Actors can forcefully stop other actors with the @ref
- simgrid::s4u::Actor::kill(void) method.
-
- - <b>Kill actors (other function)</b>.
- @ref examples/s4u/actor-kill-pid/s4u-actor-kill-pid.cpp \n
- Actors can forcefully stop other actors with the @ref
- simgrid::s4u::Actor::kill(aid_t) method.
+ simgrid::s4u::Actor::kill(void) or the @ref
+ simgrid::s4u::Actor::kill(aid_t) methods.
- <b>Controling the actor life cycle from the XML</b>.
@ref examples/s4u/actor-lifetime/s4u-actor-lifetime.cpp
* You are not expected to use them directly but to create them
* implicitely through a @ref simgrid::kernel::Promise.
* Alternatively kernel operations could inherit or contain FutureState
- * if they are managed with @ref std::shared_ptr.
+ * if they are managed with std::shared_ptr.
**/
template<class T>
class FutureState : public FutureStateBase {
* );
* </pre>
*
- * This is based on C++1z @ref std::future but with some differences:
+ * This is based on C++1z std::future but with some differences:
*
* * there is no thread synchronization (atomic, mutex, condition variable,
* etc.) because everything happens in the SimGrid event loop;
/** Get the value from the future
*
* The future must be valid and ready in order to make this call.
- * @ref std::future blocks when the future is not ready but we are
+ * std::future blocks when the future is not ready but we are
* completely single-threaded so blocking would be a deadlock.
* After the call, the future becomes invalid.
*
* A @ref Promise is connected to some `Future` and can be used to
* set its result.
*
- * Similar to @ref std::promise
+ * Similar to std::promise
*
* <code>
* // Create a promise and a future:
/**
* Base class for all ReplayActions.
* Note that this class actually implements the behavior of each action
- * while the parsing of the replay arguments is done in the @ActionArgParser class.
+ * while the parsing of the replay arguments is done in the ActionArgParser class.
* In other words: The logic goes here, the setup is done by the ActionArgParser.
*/
template <class T> class ReplayAction {
* Change a user state previously declared to the given value.
*
* \param host The name of the host to be considered.
- * \param state The name of the state previously declared.
- * \param value The new value of the state.
+ * \param state_name The name of the state previously declared.
+ * \param value_name The new value of the state.
*
* \see TRACE_host_state_declare, TRACE_host_push_state, TRACE_host_pop_state, TRACE_host_reset_state
*/
LinkType::LinkType(std::string name, std::string alias, Type* father) : ValueType(name, alias, father)
{
}
-void LinkType::startEvent(container_t startContainer, std::string value, std::string key)
+void LinkType::startEvent(Container* startContainer, std::string value, std::string key)
{
startEvent(startContainer, value, key, -1);
}
-void LinkType::startEvent(container_t startContainer, std::string value, std::string key, int size)
+void LinkType::startEvent(Container* startContainer, std::string value, std::string key, int size)
{
new LinkEvent(issuer_, this, PAJE_StartLink, startContainer, value, key, size);
}
-void LinkType::endEvent(container_t endContainer, std::string value, std::string key)
+void LinkType::endEvent(Container* endContainer, std::string value, std::string key)
{
new LinkEvent(issuer_, this, PAJE_EndLink, endContainer, value, key, -1);
}
/**
* \brief Handle a condition waiting simcall without timeouts
- * \param simcall the simcall
*/
void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex)
{
/**
* \brief Handle a condition waiting simcall with timeouts
- * \param simcall the simcall
*/
void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout)
{
*
* Signalizes a condition and wakes up a sleeping process.
* If there are no process sleeping, no action is done.
- * \param cond A condition
*/
void ConditionVariableImpl::signal()
{
* @brief creates a new context for a user level process
* @param code a main function
* @param cleanup_func the function to call when the context stops
+ * @param simix_process
*/
smx_context_t SIMIX_context_new(
std::function<void()> code,
/** \brief Attribute the value bound to var->bound.
*
+ * \param func_f function (f)
+ * \param func_fp partial differential of f (f prime, (f'))
* \param func_fpi inverse of the partial differential of f (f prime inverse, (f')^{-1})
*
* Set default functions to the ones passed as parameters.
* The estimation is very approximative because the value returned is the time the task would take if it was executed
* now and if it was the only task.
*
- * \param task the task to evaluate
* \param host_count number of hosts on which the task would be executed
* \param host_list the hosts on which the task would be executed
* \param flops_amount computation amount for each host(i.e., an array of host_count doubles)
* \param code the main function of the process
* \param data a pointer to any data one may want to attach to the new object. It is for user-level information and can
* be nullptr.
- * It can be retrieved with the function \ref simcall_process_get_data.
+ * It can be retrieved with the method ActorImpl::getUserData().
* \param host where the new agent is executed.
* \param argc first argument passed to \a code
* \param argv second argument passed to \a code
* \param flops_amount amount Computation amount (in flops)
* \param priority computation priority
* \param bound
+ * \param host host where the synchro will be executed
* \return A new SIMIX execution synchronization
*/
smx_activity_t simcall_execution_start(const char* name, double flops_amount, double priority, double bound,
/**
* \brief Handles a sem acquire simcall without timeout.
- * \param simcall the simcall
*/
void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem)
{
/**
* \brief Handles a sem acquire simcall with timeout.
- * \param simcall the simcall
*/
void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout)
{
refcount_ = 1;
}
-Group::Group(MPI_Group origin)
+Group::Group(Group* origin)
{
if (origin != MPI_GROUP_NULL && origin != MPI_GROUP_EMPTY) {
size_ = origin->size();
**********/
/** @ingroup SURF_network_interface
* @brief SURF network action interface class
- * @details A NetworkAction represents a communication between two [hosts](\ref HostImpl)
+ * @details A NetworkAction represents a communication between two [hosts](\ref simgrid::surf::HostImpl)
*/
class NetworkAction : public Action {
public:
/**
* Add this to your host tag:
- * - <prop id="plugin/dvfs/governor" value="performance" />
+ * - \<prop id="plugin/dvfs/governor" value="performance" /\>
*
* Valid values as of now are: performance, powersave, ondemand, conservative
* It doesn't matter if you use uppercase or lowercase.
*
* For the sampling rate, use this:
*
- * - <prop id="plugin/dvfs/sampling_rate" value="2" />
+ * - \<prop id="plugin/dvfs/sampling_rate" value="2" /\>
*
* This will run the update() method of the specified governor every 2 seconds
* on that host.
*
- * These properties can also be used within the <config> tag to configure
- * these values globally. Using them within the <host> will overwrite this
+ * These properties can also be used within the \<config\> tag to configure
+ * these values globally. Using them within the \<host\> will overwrite this
* global configuration
*/
class HostDvfs {
This is enough to compute the consumption as a function of the amount of loaded cores:
<table>
-<tr><th>#Cores loaded</th><th>Consumption</th><th>Explanation</th></tr>
+<tr><th>\#Cores loaded</th><th>Consumption</th><th>Explanation</th></tr>
<tr><td>0</td><td> 100 Watts</td><td>Idle value</td></tr>
<tr><td>1</td><td> 120 Watts</td><td>OneCore value</td></tr>
<tr><td>2</td><td> 147 Watts</td><td>linear extrapolation between OneCore and AllCores</td></tr>
return heap_.empty() ? -1.0 : heap_.top().first;
}
-/** @brief Retrieves the next occurring event, or nullptr if none happens before #date */
+/** @brief Retrieves the next occurring event, or nullptr if none happens before date */
tmgr_trace_event_t simgrid::trace_mgr::future_evt_set::pop_leq(double date, double* value,
kernel::resource::Resource** resource)
{
/** @brief Modeling of the availability profile (due to an external load) or the churn
*
* There is 4 main concepts in this module:
- * - #DatedValue: a pair <timestamp, value> (both are of type double)
- * - #trace: a list of dated values
- * - #trace_event: links a given trace to a given SimGrid resource.
+ * - #simgrid::trace_mgr::DatedValue: a pair <timestamp, value> (both are of type double)
+ * - #simgrid::trace_mgr::trace: a list of dated values
+ * - #simgrid::trace_mgr::trace_event: links a given trace to a given SimGrid resource.
* A Cpu for example has 2 kinds of events: state (ie, is it ON/OFF) and speed,
* while a link has 3 iterators: state, bandwidth and latency.
- * - #future_evt_set: makes it easy to find the next occuring event of all traces
+ * - #simgrid::trace_mgr::future_evt_set: makes it easy to find the next occuring event of all traces
*/
namespace trace_mgr {
class XBT_PUBLIC DatedValue {
