/* Maximum size of the application heap.
*
- * The model-checker heap is placed at this offset from the
- * beginning of the application heap.
+ * The model-checker heap is placed at this offset from the beginning of the application heap.
*
- * In the current implementation, if the application uses more
- * than this for the application heap the application heap will
- * smash the beginning of the model-checker heap and bad things
- * will happen.
+ * In the current implementation, if the application uses more than this for the application heap the application heap
+ * will smash the beginning of the model-checker heap and bad things will happen.
*
- * For 64 bits systems, we have a lot of virtual memory available
- * so we wan use a much bigger value in order to avoid bad things
- * from happening.
+ * For 64 bits systems, we have a lot of virtual memory available so we wan use a much bigger value in order to avoid
+ * bad things from happening.
* */
#define STD_HEAP_SIZE (sizeof(void*)<=4 ? (100*1024*1024) : (1ll*1024*1024*1024*1024))
SG_BEGIN_DECL()
/********************************** Configuration of MC **************************************/
-
extern XBT_PUBLIC(int) _sg_do_model_check;
extern XBT_PRIVATE int _sg_do_model_check_record;
extern XBT_PRIVATE int _sg_mc_checkpoint;
extern XBT_PRIVATE int _sg_mc_termination;
/********************************* Global *************************************/
-
XBT_PRIVATE void _mc_cfg_cb_reduce(const char *name, int pos);
XBT_PRIVATE void _mc_cfg_cb_checkpoint(const char *name, int pos);
XBT_PRIVATE void _mc_cfg_cb_sparse_checkpoint(const char *name, int pos);
#include "xbt/config.h"
-/*******************************************/
-/*** Config Globals **************************/
-/*******************************************/
-
+/** Config Globals */
SG_BEGIN_DECL()
XBT_PUBLIC_DATA(xbt_cfg_t) _sg_cfg_set;
SG_BEGIN_DECL()
-/** \brief MPI collective description
- */
+/** \brief MPI collective description */
typedef struct mpi_coll_description {
const char *name;
void *coll;
} s_mpi_coll_description_t, *mpi_coll_description_t;
-
/** \ingroup MPI gather
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_gather_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_gather_fun)
- (void *, int, MPI_Datatype, void *, int, MPI_Datatype,
- int, MPI_Comm));
+XBT_PUBLIC_DATA(int (*mpi_coll_gather_fun)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, int, MPI_Comm));
/** \ingroup MPI allgather
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_allgather_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_allgather_fun)
- (void *, int, MPI_Datatype, void *, int, MPI_Datatype,
- MPI_Comm));
+XBT_PUBLIC_DATA(int (*mpi_coll_allgather_fun) (void *, int, MPI_Datatype, void *, int, MPI_Datatype, MPI_Comm));
/** \ingroup MPI allgather
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_allgatherv_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_allgatherv_fun)
- (void *, int, MPI_Datatype, void *, int*, int*, MPI_Datatype,
- MPI_Comm));
-
+XBT_PUBLIC_DATA(int (*mpi_coll_allgatherv_fun) (void *, int, MPI_Datatype, void *, int*, int*, MPI_Datatype, MPI_Comm));
/** \ingroup MPI allreduce
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_allreduce_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_allreduce_fun)
- (void *sbuf, void *rbuf, int rcount, MPI_Datatype dtype,
- MPI_Op op, MPI_Comm comm));
-
+XBT_PUBLIC_DATA(int (*mpi_coll_allreduce_fun)(void *sbuf, void *rbuf, int rcount, MPI_Datatype dtype,MPI_Op op,
+ MPI_Comm comm));
/** \ingroup MPI alltoall
* \brief The list of all available alltoall collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_alltoall_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_alltoall_fun)
- (void *, int, MPI_Datatype, void *, int, MPI_Datatype,
- MPI_Comm));
+XBT_PUBLIC_DATA(int (*mpi_coll_alltoall_fun)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, MPI_Comm));
/** \ingroup MPI alltoallv
* \brief The list of all available alltoallv collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_alltoallv_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_alltoallv_fun)
- (void *, int*, int*, MPI_Datatype, void *, int*, int*, MPI_Datatype,
- MPI_Comm));
-
+XBT_PUBLIC_DATA(int (*mpi_coll_alltoallv_fun)(void *, int*, int*, MPI_Datatype, void *, int*, int*, MPI_Datatype,
+ MPI_Comm));
/** \ingroup MPI bcast
* \brief The list of all available bcast collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_bcast_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_bcast_fun)
- (void *buf, int count, MPI_Datatype datatype, int root,
- MPI_Comm com));
-
+XBT_PUBLIC_DATA(int (*mpi_coll_bcast_fun)(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm com));
/** \ingroup MPI reduce
* \brief The list of all available reduce collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_reduce_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_reduce_fun)
- (void *buf, void *rbuf, int count, MPI_Datatype datatype,
- MPI_Op op, int root, MPI_Comm comm));
+XBT_PUBLIC_DATA(int (*mpi_coll_reduce_fun)(void *buf, void *rbuf, int count, MPI_Datatype datatype,
+ MPI_Op op, int root, MPI_Comm comm));
/** \ingroup MPI reduce_scatter
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_reduce_scatter_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_reduce_scatter_fun)
- (void *sbuf, void *rbuf, int *rcounts,
+XBT_PUBLIC_DATA(int (*mpi_coll_reduce_scatter_fun) (void *sbuf, void *rbuf, int *rcounts,
MPI_Datatype dtype, MPI_Op op,MPI_Comm comm));
/** \ingroup MPI scatter
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_scatter_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_scatter_fun)
- (void *sendbuf, int sendcount, MPI_Datatype sendtype,
- void *recvbuf, int recvcount, MPI_Datatype recvtype,
- int root, MPI_Comm comm));
+XBT_PUBLIC_DATA(int (*mpi_coll_scatter_fun)(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+ void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm));
/** \ingroup MPI barrier
* \brief The list of all available allgather collectives
*/
XBT_PUBLIC_DATA(s_mpi_coll_description_t) mpi_coll_barrier_description[];
-XBT_PUBLIC_DATA(int (*mpi_coll_barrier_fun)
- (MPI_Comm comm));
-
-
-XBT_PUBLIC(void) coll_help(const char *category,
- s_mpi_coll_description_t * table);
-XBT_PUBLIC(int) find_coll_description(s_mpi_coll_description_t * table,
- char *name, const char *desc);
+XBT_PUBLIC_DATA(int (*mpi_coll_barrier_fun)(MPI_Comm comm));
+XBT_PUBLIC(void) coll_help(const char *category, s_mpi_coll_description_t * table);
+XBT_PUBLIC(int) find_coll_description(s_mpi_coll_description_t * table, char *name, const char *desc);
extern XBT_PRIVATE double smpi_wtime_sleep;
extern XBT_PRIVATE double smpi_iprobe_sleep;
typedef struct tmgr_trace_iterator *tmgr_trace_iterator_t;
-
#endif /* MAXMIN_DATATYPES_H */
#include "surf/datatypes.h"
#include <math.h>
-
/** @addtogroup SURF_lmm
* @details
* A linear maxmin solver to resolve inequations systems.
*
- * Most SimGrid model rely on a "fluid/steady-state" modeling that
- * simulate the sharing of resources between actions at relatively
- * coarse-grain. Such sharing is generally done by solving a set of
- * linear inequations. Let's take an example and assume we have the
- * variables \f$x_1\f$, \f$x_2\f$, \f$x_3\f$, and \f$x_4\f$ . Let's
- * say that \f$x_1\f$ and \f$x_2\f$ correspond to activities running
- * and the same CPU \f$A\f$ whose capacity is \f$C_A\f$. In such a
+ * Most SimGrid model rely on a "fluid/steady-state" modeling that simulate the sharing of resources between actions at
+ * relatively coarse-grain. Such sharing is generally done by solving a set of linear inequations. Let's take an
+ * example and assume we have the variables \f$x_1\f$, \f$x_2\f$, \f$x_3\f$, and \f$x_4\f$ . Let's say that \f$x_1\f$
+ * and \f$x_2\f$ correspond to activities running and the same CPU \f$A\f$ whose capacity is \f$C_A\f$. In such a
* case, we need to enforce:
*
* \f[ x_1 + x_2 \leq C_A \f]
*
- * Likewise, if \f$x_3\f$ (resp. \f$x_4\f$) corresponds to a network
- * flow \f$F_3\f$ (resp. \f$F_4\f$) that goes through a set of links
- * \f$L_1\f$ and \f$L_2\f$ (resp. \f$L_2\f$ and \f$L_3\f$), then we
- * need to enforce:
+ * Likewise, if \f$x_3\f$ (resp. \f$x_4\f$) corresponds to a network flow \f$F_3\f$ (resp. \f$F_4\f$) that goes through
+ * a set of links \f$L_1\f$ and \f$L_2\f$ (resp. \f$L_2\f$ and \f$L_3\f$), then we need to enforce:
*
* \f[ x_3 \leq C_{L_1} \f]
* \f[ x_3 + x_4 \leq C_{L_2} \f]
* \f[ x_4 \leq C_{L_3} \f]
- *
- * One could set every variable to 0 to make sure the constraints are
- * satisfied but this would obviously not be very realistic. A
- * possible objective is to try to maximize the minimum of the
- * \f$x_i\f$ . This ensures that all the \f$x_i\f$ are positive and "as
- * large as possible".
*
- * This is called *max-min fairness* and is the most commonly used
- * objective in SimGrid. Another possibility is to maximize
- * \f$\sum_if(x_i)\f$, where \f$f\f$ is a strictly increasing concave
- * function.
+ * One could set every variable to 0 to make sure the constraints are satisfied but this would obviously not be very
+ * realistic. A possible objective is to try to maximize the minimum of the \f$x_i\f$ . This ensures that all the
+ * \f$x_i\f$ are positive and "as large as possible".
*
+ * This is called *max-min fairness* and is the most commonly used objective in SimGrid. Another possibility is to
+ * maximize \f$\sum_if(x_i)\f$, where \f$f\f$ is a strictly increasing concave function.
*
* Constraint:
* - bound (set)
* max( var1.weight * var1.value * elem5.value , var3.weight * var3.value * elem6.value ) <= cons3.bound
*
* This is usefull for the sharing of resources for various models.
- * For instance, for the network model, each link is associated
- * to a constraint and each communication to a variable.
- *
+ * For instance, for the network model, each link is associated to a constraint and each communication to a variable.
*
* Implementation details
*
- * For implementation reasons, we are interested in distinguishing variables that actually participate to the computation of constraints, and those who are part of the equations but are stuck to zero.
- * We call enabled variables, those which var.weight is strictly positive. Zero-weight variables are called disabled variables.
+ * For implementation reasons, we are interested in distinguishing variables that actually participate to the
+ * computation of constraints, and those who are part of the equations but are stuck to zero.
+ * We call enabled variables, those which var.weight is strictly positive. Zero-weight variables are called disabled
+ * variables.
* Unfortunately this concept of enabled/disabled variables intersects with active/inactive variable.
- * Semantically, the intent is similar, but the conditions under which a variable is active is slightly more strict than the conditions for it to be enabled.
+ * Semantically, the intent is similar, but the conditions under which a variable is active is slightly more strict
+ * than the conditions for it to be enabled.
* A variable is active only if its var.value is non-zero (and, by construction, its var.weight is non-zero).
- * In general, variables remain disabled after their creation, which often models an initialization phase (e.g. first packet propagating in the network). Then, it is enabled by the corresponding model. Afterwards, the max-min solver (lmm_solve()) activates it when appropriate. It is possible that the variable is again disabled, e.g. to model the pausing of an action.
- *
+ * In general, variables remain disabled after their creation, which often models an initialization phase (e.g. first
+ * packet propagating in the network). Then, it is enabled by the corresponding model. Afterwards, the max-min solver
+ * (lmm_solve()) activates it when appropriate. It is possible that the variable is again disabled, e.g. to model the
+ * pausing of an action.
*
* Concurrency limit and maximum
*
* We call concurrency, the number of variables that can be enabled at any time for each constraint.
- * From a model perspective, this "concurrency" often represents the number of actions that actually compete for one constraint.
+ * From a model perspective, this "concurrency" often represents the number of actions that actually compete for one
+ * constraint.
* The LMM solver is able to limit the concurrency for each constraint, and to monitor its maximum value.
*
* One may want to limit the concurrency of constraints for essentially three reasons:
- * - Keep LMM system in a size that can be solved (it does not react very well with tens of thousands of variables per constraint)
+ * - Keep LMM system in a size that can be solved (it does not react very well with tens of thousands of variables per
+ * constraint)
* - Stay within parameters where the fluid model is accurate enough.
* - Model serialization effects
*
- * The concurrency limit can also be set to a negative value to disable concurrency limit. This can improve performance slightly.
+ * The concurrency limit can also be set to a negative value to disable concurrency limit. This can improve performance
+ * slightly.
*
* Overall, each constraint contains three fields related to concurrency:
* - concurrency_limit which is the limit enforced by the solver
* Variables also have one field related to concurrency: concurrency_share.
* In effect, in some cases, one variable is involved multiple times (i.e. two elements) in a constraint.
* For example, cross-traffic is modeled using 2 elements per constraint.
- * concurrency_share formally corresponds to the maximum number of elements that associate the variable and any given constraint.
+ * concurrency_share formally corresponds to the maximum number of elements that associate the variable and any given
+ * constraint.
*/
XBT_PUBLIC_DATA(double) sg_maxmin_precision;
{
//printf("Updating %g -= %g +- %g\n",*variable,value,precision);
//xbt_assert(value==0 || value>precision);
- //Check that precision is higher than the machine-dependent size of the mantissa. If not, brutal rounding may happen, and the precision mechanism is not active...
+ //Check that precision is higher than the machine-dependent size of the mantissa. If not, brutal rounding may happen,
+ //and the precision mechanism is not active...
//xbt_assert(*variable< (2<<DBL_MANT_DIG)*precision && FLT_RADIX==2);
*variable -= value;
if (*variable < precision)
/** @{ @ingroup SURF_lmm */
/**
* @brief Create a new Linear MaxMim system
- *
* @param selective_update [description]
*/
XBT_PUBLIC(lmm_system_t) lmm_system_new(int selective_update);
/**
* @brief Free an existing Linear MaxMin system
- *
* @param sys The lmm system to free
*/
XBT_PUBLIC(void) lmm_system_free(lmm_system_t sys);
/**
* @brief Create a new Linear MaxMin constraint
- *
* @param sys The system in which we add a constraint
* @param id Data associated to the constraint (e.g.: a network link)
* @param bound_value The bound value of the constraint
*/
-XBT_PUBLIC(lmm_constraint_t) lmm_constraint_new(lmm_system_t sys, void *id,
- double bound_value);
+XBT_PUBLIC(lmm_constraint_t) lmm_constraint_new(lmm_system_t sys, void *id,double bound_value);
/**
* @brief Share a constraint
- * @details [long description]
- *
* @param cnst The constraint to share
*/
XBT_PUBLIC(void) lmm_constraint_shared(lmm_constraint_t cnst);
/**
* @brief Check if a constraint is shared (shared by default)
- *
* @param cnst The constraint to share
* @return 1 if shared, 0 otherwise
*/
/**
* @brief Free a constraint
- *
* @param sys The system associated to the constraint
* @param cnst The constraint to free
*/
/**
* @brief Get the usage of the constraint after the last lmm solve
- *
* @param cnst A constraint
* @return The usage of the constraint
*/
/**
* @brief Sets the concurrency limit for this constraint
- *
* @param cnst A constraint
* @param concurrency_limit The concurrency limit to use for this constraint
*/
/**
* @brief Gets the concurrency limit for this constraint
- *
* @param cnst A constraint
* @return The concurrency limit used by this constraint
*/
XBT_PUBLIC(int) lmm_constraint_concurrency_limit_get(lmm_constraint_t cnst);
-
/**
- * @brief Reset the concurrency maximum for a given variable (we will update the maximum to reflect constraint evolution).
- *
+ * @brief Reset the concurrency maximum for a given variable (we will update the maximum to reflect constraint
+ * evolution).
* @param cnst A constraint
- *
*/
XBT_PUBLIC(void) lmm_constraint_concurrency_maximum_reset(lmm_constraint_t cnst);
-
/**
* @brief Get the concurrency maximum for a given variable (which reflects constraint evolution).
- *
* @param cnst A constraint
* @return the maximum concurrency of the constraint
*/
XBT_PUBLIC(int) lmm_constraint_concurrency_maximum_get(lmm_constraint_t cnst);
-
/**
* @brief Create a new Linear MaxMin variable
- *
* @param sys The system in which we add a constaint
* @param id Data associated to the variable (e.g.: a network communication)
* @param weight_value The weight of the variable (0.0 if not used)
* @param bound The maximum value of the variable (-1.0 if no maximum value)
* @param number_of_constraints The maximum number of constraint to associate to the variable
*/
-XBT_PUBLIC(lmm_variable_t) lmm_variable_new(lmm_system_t sys, void *id,
- double weight_value,
- double bound,
+XBT_PUBLIC(lmm_variable_t) lmm_variable_new(lmm_system_t sys, void *id, double weight_value, double bound,
int number_of_constraints);
/**
* @brief Free a variable
- *
* @param sys The system associated to the variable
* @param var The variable to free
*/
/**
* @brief Get the value of the variable after the last lmm solve
- *
* @param var A variable
* @return The value of the variable
*/
/**
* @brief Get the maximum value of the variable (-1.0 if no maximum value)
- *
* @param var A variable
* @return The bound of the variable
*/
/**
* @brief Set the concurrent share of the variable
- *
* @param var A variable
* @param concurrency_share The new concurrency share
*/
/**
* @brief Remove a variable from a constraint
- *
* @param sys A system
* @param cnst A constraint
* @param var The variable to remove
*/
-XBT_PUBLIC(void) lmm_shrink(lmm_system_t sys, lmm_constraint_t cnst,
- lmm_variable_t var);
+XBT_PUBLIC(void) lmm_shrink(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var);
/**
* @brief Associate a variable to a constraint with a coefficient
- *
* @param sys A system
* @param cnst A constraint
* @param var A variable
* @param value The coefficient associated to the variable in the constraint
*/
-XBT_PUBLIC(void) lmm_expand(lmm_system_t sys, lmm_constraint_t cnst,
- lmm_variable_t var, double value);
+XBT_PUBLIC(void) lmm_expand(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, double value);
/**
- * @brief Add value to the coefficient between a constraint and a variable or
- * create one
- *
+ * @brief Add value to the coefficient between a constraint and a variable or create one
* @param sys A system
* @param cnst A constraint
* @param var A variable
* @param value The value to add to the coefficient associated to the variable in the constraint
*/
-XBT_PUBLIC(void) lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst,
- lmm_variable_t var, double value);
+XBT_PUBLIC(void) lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, double value);
/**
* @brief Get the numth constraint associated to the variable
- *
* @param sys The system associated to the variable (not used)
* @param var A variable
* @param num The rank of constraint we want to get
* @return The numth constraint
*/
-XBT_PUBLIC(lmm_constraint_t) lmm_get_cnst_from_var(lmm_system_t sys,
- lmm_variable_t var, int num);
+XBT_PUBLIC(lmm_constraint_t) lmm_get_cnst_from_var(lmm_system_t sys, lmm_variable_t var, int num);
/**
* @brief Get the weigth of the numth constraint associated to the variable
- *
* @param sys The system associated to the variable (not used)
* @param var A variable
* @param num The rank of constraint we want to get
* @return The numth constraint
*/
-XBT_PUBLIC(double) lmm_get_cnst_weight_from_var(lmm_system_t sys, lmm_variable_t var,
- int num);
+XBT_PUBLIC(double) lmm_get_cnst_weight_from_var(lmm_system_t sys, lmm_variable_t var, int num);
/**
* @brief Get the number of constraint associated to a variable
- *
* @param sys The system associated to the variable (not used)
* @param var A variable
* @return The number of constraint associated to the variable
/**
* @brief Get a var associated to a constraint
* @details Get the first variable of the next variable of elem if elem is not NULL
- *
* @param sys The system associated to the variable (not used)
* @param cnst A constraint
* @param elem A element of constraint of the constraint or NULL
* @return A variable associated to a constraint
*/
-XBT_PUBLIC(lmm_variable_t) lmm_get_var_from_cnst(lmm_system_t sys,
- lmm_constraint_t cnst,
- lmm_element_t * elem);
+XBT_PUBLIC(lmm_variable_t) lmm_get_var_from_cnst(lmm_system_t sys, lmm_constraint_t cnst, lmm_element_t * elem);
/**
* @brief Get a var associated to a constraint
* @details Get the first variable of the next variable of elem if elem is not NULL
- *
* @param cnst A constraint
* @param elem A element of constraint of the constraint or NULL
* @param nextelem A element of constraint of the constraint or NULL, the one after elem
*
* @return A variable associated to a constraint
*/
-XBT_PUBLIC(lmm_variable_t) lmm_get_var_from_cnst_safe(lmm_system_t /*sys*/,
- lmm_constraint_t cnst,
- lmm_element_t * elem,
- lmm_element_t * nextelem,
- int * numelem);
+XBT_PUBLIC(lmm_variable_t) lmm_get_var_from_cnst_safe(lmm_system_t /*sys*/, lmm_constraint_t cnst,
+ lmm_element_t * elem, lmm_element_t * nextelem, int * numelem);
/**
* @brief Get the first active constraint of a system
- *
* @param sys A system
* @return The first active constraint
*/
/**
* @brief Get the next active constraint of a constraint in a system
- *
* @param sys A system
* @param cnst An active constraint of the system
*
* @return The next active constraint
*/
-XBT_PUBLIC(lmm_constraint_t) lmm_get_next_active_constraint(lmm_system_t sys,
- lmm_constraint_t cnst);
+XBT_PUBLIC(lmm_constraint_t) lmm_get_next_active_constraint(lmm_system_t sys, lmm_constraint_t cnst);
#ifdef HAVE_LATENCY_BOUND_TRACKING
XBT_PUBLIC(int) lmm_is_variable_limited_by_latency(lmm_variable_t var);
/**
* @brief Get the data associated to a constraint
- *
* @param cnst A constraint
* @return The data associated to the constraint
*/
/**
* @brief Get the data associated to a variable
- *
* @param var A variable
* @return The data associated to the variable
*/
/**
* @brief Update the value of element linking the constraint and the variable
- *
* @param sys A system
* @param cnst A constraint
* @param var A variable
* @param value The new value
*/
-XBT_PUBLIC(void) lmm_update(lmm_system_t sys, lmm_constraint_t cnst,
- lmm_variable_t var, double value);
+XBT_PUBLIC(void) lmm_update(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, double value);
/**
* @brief Update the bound of a variable
- *
* @param sys A system
* @param var A constraint
* @param bound The new bound
*/
-XBT_PUBLIC(void) lmm_update_variable_bound(lmm_system_t sys, lmm_variable_t var,
- double bound);
+XBT_PUBLIC(void) lmm_update_variable_bound(lmm_system_t sys, lmm_variable_t var, double bound);
/**
* @brief Update the weight of a variable
- *
* @param sys A system
* @param var A variable
* @param weight The new weight of the variable
*/
-XBT_PUBLIC(void) lmm_update_variable_weight(lmm_system_t sys,
- lmm_variable_t var,
- double weight);
+XBT_PUBLIC(void) lmm_update_variable_weight(lmm_system_t sys, lmm_variable_t var, double weight);
/**
* @brief Get the weight of a variable
- *
* @param var A variable
* @return The weight of the variable
*/
/**
* @brief Update a constraint bound
- *
* @param sys A system
* @param cnst A constraint
* @param bound The new bound of the consrtaint
*/
-XBT_PUBLIC(void) lmm_update_constraint_bound(lmm_system_t sys,
- lmm_constraint_t cnst,
- double bound);
+XBT_PUBLIC(void) lmm_update_constraint_bound(lmm_system_t sys, lmm_constraint_t cnst, double bound);
/**
* @brief [brief description]
- *
* @param sys A system
* @param cnst A constraint
* @return [description]
/**
* @brief Print the lmm system
- *
* @param sys The lmm system to print
*/
XBT_PUBLIC(void) lmm_print(lmm_system_t sys);
-
+
/**
* @brief Solve the lmm system
- *
* @param sys The lmm system to solve
*/
XBT_PUBLIC(void) lmm_solve(lmm_system_t sys);
XBT_PUBLIC(void) lagrange_solve(lmm_system_t sys);
XBT_PUBLIC(void) bottleneck_solve(lmm_system_t sys);
-/**
- * Default functions associated to the chosen protocol. When
- * using the lagrangian approach.
- */
+/** Default functions associated to the chosen protocol. When using the lagrangian approach. */
-XBT_PUBLIC(void) lmm_set_default_protocol_function(double (*func_f)
- (lmm_variable_t var,
- double x),
- double (*func_fp)
- (lmm_variable_t var,
- double x),
- double (*func_fpi)
- (lmm_variable_t var,
- double x));
+XBT_PUBLIC(void) lmm_set_default_protocol_function(double (*func_f)(lmm_variable_t var,double x),
+ double (*func_fp)(lmm_variable_t var,double x),
+ double (*func_fpi)(lmm_variable_t var,double x));
XBT_PUBLIC(double func_reno_f) (lmm_variable_t var, double x);
XBT_PUBLIC(double func_reno_fp) (lmm_variable_t var, double x);
class StorageActionLmm;
class As;
class RoutingPlatf;
-
}
}
/** \ingroup SURF_models
* \brief Initializes the CPU model with the model Cas01
*
- * By default, this model uses the lazy optimization mechanism that
- * relies on partial invalidation in LMM and a heap for lazy action update.
- * You can change this behavior by setting the cpu/optim configuration
- * variable to a different value.
+ * By default, this model uses the lazy optimization mechanism that relies on partial invalidation in LMM and a heap
+ * for lazy action update.
+ * You can change this behavior by setting the cpu/optim configuration variable to a different value.
*
* You shouldn't have to call it by yourself.
*/
*/
XBT_PUBLIC_DATA(s_surf_model_description_t) surf_cpu_model_description[];
-/**\brief create new host bypass the parser
- *
- */
-
-
/** \ingroup SURF_models
* \brief The network model
*
- * When creating a new API on top on SURF, you shouldn't use the
- * network model unless you know what you are doing. Only the host
- * model should be accessed because depending on the platform model,
- * the network model can be NULL.
+ * When creating a new API on top on SURF, you shouldn't use the network model unless you know what you are doing.
+ * Only the host model should be accessed because depending on the platform model, the network model can be NULL.
*/
XBT_PUBLIC_DATA(surf_network_model_t) surf_network_model;
/** \ingroup SURF_models
* \brief Same as network model 'LagrangeVelho', only with different correction factors.
*
- * This model is proposed by Pierre-Nicolas Clauss and Martin Quinson and Stéphane Génaud
- * based on the model 'LV08' and different correction factors depending on the communication
- * size (< 1KiB, < 64KiB, >= 64KiB).
+ * This model is proposed by Pierre-Nicolas Clauss and Martin Quinson and Stéphane Génaud based on the model 'LV08' and
+ * different correction factors depending on the communication size (< 1KiB, < 64KiB, >= 64KiB).
* See comments in the code for more information.
*
* \see surf_host_model_init_SMPI()
/** \ingroup SURF_models
* \brief Initializes the platform with the network model 'LegrandVelho'
*
- * This model is proposed by Arnaud Legrand and Pedro Velho based on
- * the results obtained with the GTNets simulator for onelink and
- * dogbone sharing scenarios. See comments in the code for more information.
+ * This model is proposed by Arnaud Legrand and Pedro Velho based on the results obtained with the GTNets simulator for
+ * onelink and dogbone sharing scenarios. See comments in the code for more information.
*
* \see surf_host_model_init_LegrandVelho()
*/
/** \ingroup SURF_models
* \brief Initializes the platform with the network model 'Constant'
*
- * In this model, the communication time between two network cards is
- * constant, hence no need for a routing table. This is particularly
- * usefull when simulating huge distributed algorithms where
- * scalability is really an issue. This function is called in
- * conjunction with surf_host_model_init_compound.
+ * In this model, the communication time between two network cards is constant, hence no need for a routing table.
+ * This is particularly useful when simulating huge distributed algorithms where scalability is really an issue. This
+ * function is called in conjunction with surf_host_model_init_compound.
*
* \see surf_host_model_init_compound()
*/
/** \ingroup SURF_models
* \brief Initializes the platform with the network model CM02
*
- * You sould call this function by yourself only if you plan using
- * surf_host_model_init_compound.
+ * You sould call this function by yourself only if you plan using surf_host_model_init_compound.
* See comments in the code for more information.
*/
XBT_PUBLIC(void) surf_network_model_init_CM02(void);
/** \ingroup SURF_models
* \brief Initializes the platform with the network model NS3
*
- * This function is called by surf_host_model_init_NS3
- * or by yourself only if you plan using surf_host_model_init_compound
+ * This function is called by surf_host_model_init_NS3 or by yourself only if you plan using
+ * surf_host_model_init_compound
*
* \see surf_host_model_init_NS3()
*/
* IEEE/ACM Transaction on Networking, 11(4):525-536, 2003.
*
* Call this function only if you plan using surf_host_model_init_compound.
- *
*/
XBT_PUBLIC(void) surf_network_model_init_Reno(void);
* IEEE/ACM Transaction on Networking, 11(4):525-536, 2003.
*
* Call this function only if you plan using surf_host_model_init_compound.
- *
*/
XBT_PUBLIC(void) surf_network_model_init_Reno2(void);
/** \ingroup SURF_models
* \brief Initializes the platform with the network model Vegas
*
- * This problem is related to max( sum( a * Df * ln(xi) ) ) which is equivalent
- * to the proportional fairness.
+ * This problem is related to max( sum( a * Df * ln(xi) ) ) which is equivalent to the proportional fairness.
*
* Reference:
* [LOW03] S. H. Low. A duality model of TCP and queue management algorithms.
* IEEE/ACM Transaction on Networking, 11(4):525-536, 2003.
*
* Call this function only if you plan using surf_host_model_init_compound.
- *
*/
XBT_PUBLIC(void) surf_network_model_init_Vegas(void);
/** \ingroup SURF_models
* \brief The list of all available network model models
*/
-XBT_PUBLIC_DATA(s_surf_model_description_t)
- surf_network_model_description[];
+XBT_PUBLIC_DATA(s_surf_model_description_t) surf_network_model_description[];
/** \ingroup SURF_models
* \brief The storage model
/** \ingroup SURF_models
* \brief The host model
*
- * Note that when you create an API on top of SURF,
- * the host model should be the only one you use
- * because depending on the platform model, the network model and the CPU model
- * may not exist.
+ * Note that when you create an API on top of SURF, the host model should be the only one you use
+ * because depending on the platform model, the network model and the CPU model may not exist.
*/
XBT_PUBLIC_DATA(surf_host_model_t) surf_host_model;
/** \ingroup SURF_models
* \brief The vm model
*
- * Note that when you create an API on top of SURF,
- * the vm model should be the only one you use
- * because depending on the platform model, the network model and the CPU model
- * may not exist.
+ * Note that when you create an API on top of SURF,the vm model should be the only one you use
+ * because depending on the platform model, the network model and the CPU model may not exist.
*/
XBT_PUBLIC_DATA(surf_vm_model_t) surf_vm_model;
/** \ingroup SURF_models
* \brief Initializes the platform with a compound host model
*
- * This function should be called after a cpu_model and a
- * network_model have been set up.
- *
+ * This function should be called after a cpu_model and a network_model have been set up.
*/
XBT_PUBLIC(void) surf_host_model_init_compound(void);
* \brief Initializes the platform with the current best network and cpu models at hand
*
* This platform model separates the host model and the network model.
- * The host model will be initialized with the model compound, the network
- * model with the model LV08 (with cross traffic support) and the CPU model with
- * the model Cas01.
+ * The host model will be initialized with the model compound, the network model with the model LV08 (with cross
+ * traffic support) and the CPU model with the model Cas01.
* Such model is subject to modification with warning in the ChangeLog so monitor it!
- *
*/
XBT_PUBLIC(void) surf_host_model_init_current_default(void);
/** \ingroup SURF_models
* \brief Initializes the platform with the model L07
*
- * With this model, only parallel tasks can be used. Resource sharing
- * is done by identifying bottlenecks and giving an equal share of
- * the model to each action.
- *
+ * With this model, only parallel tasks can be used. Resource sharing is done by identifying bottlenecks and giving an
+ * equal share of the model to each action.
*/
XBT_PUBLIC(void) surf_host_model_init_ptask_L07(void);
/** \ingroup SURF_models
* \brief The list of all available host model models
*/
-XBT_PUBLIC_DATA(s_surf_model_description_t)
- surf_host_model_description[];
+XBT_PUBLIC_DATA(s_surf_model_description_t) surf_host_model_description[];
/** \ingroup SURF_models
* \brief Initializes the platform with the current best network and cpu models at hand
*
* This platform model seperates the host model and the network model.
- * The host model will be initialized with the model compound, the network
- * model with the model LV08 (with cross traffic support) and the CPU model with
- * the model Cas01.
+ * The host model will be initialized with the model compound, the network model with the model LV08 (with cross
+ * traffic support) and the CPU model with the model Cas01.
* Such model is subject to modification with warning in the ChangeLog so monitor it!
- *
*/
XBT_PUBLIC(void) surf_vm_model_init_HL13(void);
/** \ingroup SURF_models
* \brief The list of all available vm model models
*/
-XBT_PUBLIC_DATA(s_surf_model_description_t)
- surf_vm_model_description[];
-
-/*******************************************/
+XBT_PUBLIC_DATA(s_surf_model_description_t) surf_vm_model_description[];
/** \ingroup SURF_models
* \brief List of initialized models
*/
XBT_PUBLIC_DATA(xbt_dict_t) watched_hosts_lib;
-/*******************************************/
/*** SURF Platform *************************/
-/*******************************************/
XBT_PUBLIC_DATA(AS_t) surf_AS_get_routing_root(void);
XBT_PUBLIC_DATA(const char *) surf_AS_get_name(AS_t as);
XBT_PUBLIC_DATA(AS_t) surf_AS_get_by_name(const char * name);
XBT_PUBLIC_DATA(xbt_dynar_t) surf_AS_get_hosts(AS_t as);
XBT_PUBLIC_DATA(void) surf_AS_get_graph(AS_t as, xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
-/*******************************************/
/*** SURF Globals **************************/
-/*******************************************/
/** \ingroup SURF_simulation
* \brief Initialize SURF
* \param argc argument number
* \param argv arguments
*
- * This function has to be called to initialize the common
- * structures. Then you will have to create the environment by
- * calling
- * e.g. surf_host_model_init_CM02()
+ * This function has to be called to initialize the common structures. Then you will have to create the environment by
+ * calling e.g. surf_host_model_init_CM02()
*
* \see surf_host_model_init_CM02(), surf_host_model_init_compound(), surf_exit()
*/
* \param max_date Maximum date to update the simulation to, or -1
* \return the elapsed time, or -1.0 if no event could be executed
*
- * This function execute all possible events, update the action states
- * and returns the time elapsed.
- * When you call execute or communicate on a model, the corresponding actions
- * are not executed immediately but only when you call surf_solve.
+ * This function execute all possible events, update the action states and returns the time elapsed.
+ * When you call execute or communicate on a model, the corresponding actions are not executed immediately but only
+ * when you call surf_solve.
* Note that the returned elapsed time can be zero.
*/
XBT_PUBLIC(double) surf_solve(double max_date);
XBT_PUBLIC(void) surf_exit(void);
/* Prototypes of the functions that handle the properties */
-XBT_PUBLIC_DATA(xbt_dict_t) current_property_set; /* the prop set for the currently parsed element (also used in SIMIX) */
-
+XBT_PUBLIC_DATA(xbt_dict_t) current_property_set;// the prop set for the currently parsed element (also used in SIMIX)
/* The same for model_prop set*/
XBT_PUBLIC_DATA(xbt_dict_t) current_model_property_set;
XBT_PUBLIC(xbt_dict_t) get_as_router_properties(const char* name);
/*
- * Returns the initial path. On Windows the initial path is
- * the current directory for the current process in the other
- * case the function returns "./" that represents the current
- * directory on Unix/Linux platforms.
+ * Returns the initial path. On Windows the initial path is the current directory for the current process in the other
+ * case the function returns "./" that represents the current directory on Unix/Linux platforms.
*/
const char *__surf_get_initial_path(void);
xbt_graph_t instr_routing_platform_graph (void);
void instr_routing_platform_graph_export_graphviz (xbt_graph_t g, const char *filename);
-
SG_END_DECL()
#endif /* _SURF_SURF_H */