#surf_host_model_init_current_default() or #surf_host_model_init_ptask_L07()
to create the platform.
- Then you can access the hosts with the global variables \ref host_list.
+ Then you can access the hosts with the \ref simgrid::s4u::Engine::get_all_hosts.
Some functions of the \ref SURF_host_interface and similar can give
you some information about:
- a host: get_speed(), get_available_speed();
/**
* 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 @ref ActionArgParser class.
* In other words: The logic goes here, the setup is done by the ActionArgParser.
*/
template <class T> class ReplayAction {
/** \brief Write into a file (local or remote)
*
* \param size of the file to write
- * \param fd is a the file descriptor
* \return the number of bytes successfully write or -1 if an error occurred
*/
sg_size_t File::write(sg_size_t size)
* The amount of flops per second available for computing depends on several things:
* - The current pstate determines the maximal peak computing speed (use @ref get_pstate_speed() to retrieve the
* computing speed you would get at another pstate)
- * - If you declared an external load, then this reduces the available computing speed (see @ref set_speed_trace())
+ * - If you declared an external load, then this reduces the available computing speed
+ * (see @ref simgrid::surf::Cpu::set_speed_trace())
*
* The remaining speed is then shared between the executions located on this host.
* You can retrieve the amount of tasks currently running on this host with @ref get_load().
}
/** @brief Get the available speed ratio, between 0 and 1.
*
- * This accounts for external load (see @ref set_speed_trace()).
+ * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_trace()).
*/
double Host::get_available_speed() const
{
* @brief Create a Cpu
*
* @param host The host that will have this CPU
- * @param speedPerPstate Processor speed (in Flops) of each pstate. This ignores any potential external load coming from a trace.
+ * @param speed_per_pstate Processor speed (in Flops) of each pstate.
+ * This ignores any potential external load coming from a trace.
* @param core The number of core of this Cpu
*/
virtual Cpu* create_cpu(simgrid::s4u::Host* host, std::vector<double>* speed_per_pstate, int core) = 0;
* @brief Execute some quantity of computation on more than one core
*
* @param size The value of the processing amount (in flop) needed to process
- * @param requestedCores The desired amount of cores. Must be >= 1
+ * @param requested_cores The desired amount of cores. Must be >= 1
* @return The CpuAction corresponding to the processing
*/
virtual simgrid::kernel::resource::Action* execution_start(double size, int requested_cores) = 0;
* \brief Outputs the content of the structure (debugging purpose)
*
* \param dict the exibitionist
- * \param output a function to dump each data in the tree (check @ref xbt_dict_dump_output_string)
+ * \param output a function to dump each data in the tree
*
- * Outputs the content of the structure. (for debugging purpose). \a output is a function to output the data. If nullptr,
- * data won't be displayed.
+ * Outputs the content of the structure. (for debugging purpose).
+ * \a output is a function to output the data. If nullptr, data won't be displayed.
*/
void xbt_dict_dump(xbt_dict_t dict, void_f_pvoid_t output)
{