gets recomputed anyway. In that case, you'd better not try to be cleaver with lazy and go for
a simple full update. */
};
- explicit Model(std::string name);
+ explicit Model(const std::string& name);
Model(const Model&) = delete;
Model& operator=(const Model&) = delete;
* Model *
*********/
-DiskModel::DiskModel(std::string name) : Model(name)
+DiskModel::DiskModel(const std::string& name) : Model(name)
{
set_maxmin_system(new lmm::System(true /* selective update */));
}
*********/
class DiskModel : public Model {
public:
- explicit DiskModel(std::string name);
+ explicit DiskModel(const std::string& name);
DiskModel(const DiskModel&) = delete;
DiskModel& operator=(const DiskModel&) = delete;
namespace kernel {
namespace resource {
-Model::Model(std::string name) : maxmin_system_(nullptr), name_(name) {}
+Model::Model(const std::string& name) : name_(name)
+{
+}
Model::~Model() =
default; // Don't move this declaration to the header, or it will break external projects such as SimGrid-FMI
}
}
-VMModel::VMModel(std::string name) : HostModel(name)
+VMModel::VMModel(const std::string& name) : HostModel(name)
{
s4u::Host::on_state_change.connect(host_state_change);
s4u::Exec::on_start.connect(add_active_exec);
*/
class XBT_PRIVATE VMModel : public surf::HostModel {
public:
- explicit VMModel(std::string name);
+ explicit VMModel(const std::string& name);
double next_occurring_event(double now) override;
void update_actions_state(double /*now*/, double /*delta*/) override{};
*/
class XBT_PRIVATE HostModel : public kernel::resource::Model {
public:
- explicit HostModel(std::string name) : Model(name) {}
+ using Model::Model;
virtual kernel::resource::Action* execute_parallel(const std::vector<s4u::Host*>& host_list,
const double* flops_amount, const double* bytes_amount,
double rate) = 0;
namespace kernel {
namespace resource {
-CpuCas01Model::CpuCas01Model(std::string name) : CpuModel(name)
+CpuCas01Model::CpuCas01Model(const std::string& name) : CpuModel(name)
{
if (config::get_value<std::string>("cpu/optim") == "Lazy")
set_update_algorithm(Model::UpdateAlgo::LAZY);
class CpuCas01Model : public CpuModel {
public:
- explicit CpuCas01Model(std::string name);
+ explicit CpuCas01Model(const std::string& name);
CpuCas01Model(const CpuCas01Model&) = delete;
CpuCas01Model& operator=(const CpuCas01Model&) = delete;
namespace kernel {
namespace resource {
-NetworkCm02Model::NetworkCm02Model(std::string name) : NetworkModel(name)
+NetworkCm02Model::NetworkCm02Model(const std::string& name) : NetworkModel(name)
{
if (config::get_value<std::string>("network/optim") == "Lazy")
set_update_algorithm(Model::UpdateAlgo::LAZY);
class NetworkCm02Model : public NetworkModel {
public:
- explicit NetworkCm02Model(std::string name);
+ explicit NetworkCm02Model(const std::string& name);
LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy) override;
void update_actions_state_lazy(double now, double delta) override;
class NetworkConstantModel : public NetworkModel {
public:
- NetworkConstantModel(std::string name) : NetworkModel(name) {}
+ using NetworkModel::NetworkModel;
Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
double next_occurring_event(double now) override;
void update_actions_state(double now, double delta) override;
namespace kernel {
namespace resource {
-NetworkIBModel::NetworkIBModel(std::string name) : NetworkSmpiModel(name)
+NetworkIBModel::NetworkIBModel(const std::string& name) : NetworkSmpiModel(name)
{
std::string IB_factors_string = config::get_value<std::string>("smpi/IB-penalty-factors");
std::vector<std::string> radical_elements;
void computeIBfactors(IBNode* root) const;
public:
- explicit NetworkIBModel(std::string name);
+ explicit NetworkIBModel(const std::string& name);
NetworkIBModel(const NetworkIBModel&) = delete;
NetworkIBModel& operator=(const NetworkIBModel&) = delete;
void updateIBfactors(NetworkAction* action, IBNode* from, IBNode* to, int remove) const;
namespace kernel {
namespace resource {
-NetworkNS3Model::NetworkNS3Model(std::string name) : NetworkModel(name)
+NetworkNS3Model::NetworkNS3Model(const std::string& name) : NetworkModel(name)
{
xbt_assert(not sg_link_energy_is_inited(),
"LinkEnergy plugin and ns-3 network models are not compatible. Are you looking for Ecofen, maybe?");
class NetworkNS3Model : public NetworkModel {
public:
- explicit NetworkNS3Model(std::string name);
+ explicit NetworkNS3Model(const std::string& name);
LinkImpl* create_link(const std::string& name, const std::vector<double>& bandwidth,
s4u::Link::SharingPolicy policy) override;
Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
namespace kernel {
namespace resource {
-NetworkSmpiModel::NetworkSmpiModel(std::string name) : NetworkCm02Model(name) {}
-
double NetworkSmpiModel::get_bandwidth_factor(double size)
{
if (smpi_bw_factor.empty())
class XBT_PRIVATE NetworkSmpiModel : public NetworkCm02Model {
public:
- explicit NetworkSmpiModel(std::string name);
+ using NetworkCm02Model::NetworkCm02Model;
double get_latency_factor(double size) override;
double get_bandwidth_factor(double size) override;
namespace simgrid {
namespace surf {
-HostL07Model::HostL07Model(std::string name) : HostModel(name)
+HostL07Model::HostL07Model(const std::string& name) : HostModel(name)
{
auto* maxmin_system = new simgrid::kernel::lmm::FairBottleneck(true /* selective update */);
set_maxmin_system(maxmin_system);
simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_cpu_pm_model(cpu_model);
}
-CpuL07Model::CpuL07Model(std::string name, HostL07Model* hmodel, kernel::lmm::System* sys)
+CpuL07Model::CpuL07Model(const std::string& name, HostL07Model* hmodel, kernel::lmm::System* sys)
: CpuModel(name), hostModel_(hmodel)
{
set_maxmin_system(sys);
set_maxmin_system(nullptr);
}
-NetworkL07Model::NetworkL07Model(std::string name, HostL07Model* hmodel, kernel::lmm::System* sys)
+NetworkL07Model::NetworkL07Model(const std::string& name, HostL07Model* hmodel, kernel::lmm::System* sys)
: NetworkModel(name), hostModel_(hmodel)
{
set_maxmin_system(sys);
*********/
class HostL07Model : public HostModel {
public:
- explicit HostL07Model(std::string name);
+ explicit HostL07Model(const std::string& name);
HostL07Model(const HostL07Model&) = delete;
HostL07Model& operator=(const HostL07Model&) = delete;
class CpuL07Model : public kernel::resource::CpuModel {
public:
- CpuL07Model(std::string name, HostL07Model* hmodel, kernel::lmm::System* sys);
+ CpuL07Model(const std::string& name, HostL07Model* hmodel, kernel::lmm::System* sys);
CpuL07Model(const CpuL07Model&) = delete;
CpuL07Model& operator=(const CpuL07Model&) = delete;
~CpuL07Model() override;
class NetworkL07Model : public kernel::resource::NetworkModel {
public:
- NetworkL07Model(std::string name, HostL07Model* hmodel, kernel::lmm::System* sys);
+ NetworkL07Model(const std::string& name, HostL07Model* hmodel, kernel::lmm::System* sys);
NetworkL07Model(const NetworkL07Model&) = delete;
NetworkL07Model& operator=(const NetworkL07Model&) = delete;
~NetworkL07Model() override;