void surf_vm_model_init_HL13()
{
- if (surf_cpu_model_vm) {
+ if (surf_cpu_model_vm != nullptr)
surf_vm_model = new simgrid::vm::VMModel();
- all_existing_models.push_back(surf_vm_model);
- }
}
namespace simgrid {
VMModel::VMModel()
{
+ all_existing_models.push_back(this);
s4u::Host::on_state_change.connect(hostStateChange);
}
algo = simgrid::kernel::resource::Model::UpdateAlgo::FULL;
surf_cpu_model_pm = new simgrid::surf::CpuCas01Model(algo);
- all_existing_models.push_back(surf_cpu_model_pm);
-
surf_cpu_model_vm = new simgrid::surf::CpuCas01Model(algo);
- all_existing_models.push_back(surf_cpu_model_vm);
}
namespace simgrid {
CpuCas01Model::CpuCas01Model(kernel::resource::Model::UpdateAlgo algo) : simgrid::surf::CpuModel(algo)
{
+ all_existing_models.push_back(this);
+
bool select = simgrid::config::get_value<bool>("cpu/maxmin-selective-update");
if (algo == Model::UpdateAlgo::LAZY) {
xbt_assert(surf_network_model == nullptr, "Cannot set the network model twice");
surf_network_model = new simgrid::kernel::resource::NetworkCm02Model();
- all_existing_models.push_back(surf_network_model);
simgrid::config::set_default<double>("network/latency-factor", 13.01);
simgrid::config::set_default<double>("network/bandwidth-factor", 0.97);
simgrid::config::set_default<double>("network/weight-S", 0.0);
surf_network_model = new simgrid::kernel::resource::NetworkCm02Model();
- all_existing_models.push_back(surf_network_model);
}
/***************************************************************************/
simgrid::config::set_default<double>("network/weight-S", 20537);
surf_network_model = new simgrid::kernel::resource::NetworkCm02Model(&simgrid::kernel::lmm::make_new_lagrange_system);
- all_existing_models.push_back(surf_network_model);
}
simgrid::config::set_default<double>("network/weight-S", 20537);
surf_network_model = new simgrid::kernel::resource::NetworkCm02Model(&simgrid::kernel::lmm::make_new_lagrange_system);
- all_existing_models.push_back(surf_network_model);
}
void surf_network_model_init_Vegas()
simgrid::config::set_default<double>("network/weight-S", 20537);
surf_network_model = new simgrid::kernel::resource::NetworkCm02Model(&simgrid::kernel::lmm::make_new_lagrange_system);
- all_existing_models.push_back(surf_network_model);
}
namespace simgrid {
: NetworkModel(simgrid::config::get_value<std::string>("network/optim") == "Full" ? Model::UpdateAlgo::FULL
: Model::UpdateAlgo::LAZY)
{
+ all_existing_models.push_back(this);
+
std::string optim = simgrid::config::get_value<std::string>("network/optim");
bool select = simgrid::config::get_value<bool>("network/maxmin-selective-update");
{
xbt_assert(surf_network_model == nullptr);
surf_network_model = new simgrid::kernel::resource::NetworkConstantModel();
- all_existing_models.push_back(surf_network_model);
}
namespace simgrid {
namespace kernel {
namespace resource {
+NetworkConstantModel::NetworkConstantModel() : NetworkModel(Model::UpdateAlgo::FULL)
+{
+ all_existing_models.push_back(this);
+}
+
LinkImpl* NetworkConstantModel::create_link(const std::string& name, double bw, double lat,
s4u::Link::SharingPolicy policy)
{
*********/
class NetworkConstantModel : public NetworkModel {
public:
- NetworkConstantModel() : NetworkModel(Model::UpdateAlgo::FULL) {}
+ NetworkConstantModel();
Action* communicate(simgrid::s4u::Host* src, simgrid::s4u::Host* dst, double size, double rate) override;
double next_occuring_event(double now) override;
void update_actions_state(double now, double delta) override;
xbt_assert(surf_network_model == nullptr, "Cannot set the network model twice");
surf_network_model = new simgrid::kernel::resource::NetworkIBModel();
- all_existing_models.push_back(surf_network_model);
simgrid::s4u::Link::on_communication_state_change.connect(IB_action_state_changed_callback);
simgrid::s4u::Link::on_communicate.connect(IB_action_init_callback);
simgrid::s4u::Host::on_creation.connect(IB_create_host_callback);
NetworkIBModel::NetworkIBModel() : NetworkSmpiModel()
{
+ /* Do not add this into all_existing_models: our ancestor already does so */
+
std::string IB_factors_string = simgrid::config::get_value<std::string>("smpi/IB-penalty-factors");
std::vector<std::string> radical_elements;
boost::split(radical_elements, IB_factors_string, boost::is_any_of(";"));
xbt_assert(surf_network_model == nullptr, "Cannot set the network model twice");
surf_network_model = new simgrid::kernel::resource::NetworkNS3Model();
- all_existing_models.push_back(surf_network_model);
}
static simgrid::config::Flag<std::string>
xbt_assert(not sg_link_energy_is_inited(),
"LinkEnergy plugin and NS3 network models are not compatible. Are you looking for Ecofen, maybe?");
+ all_existing_models.push_back(this);
+
NetPointNs3::EXTENSION_ID = simgrid::kernel::routing::NetPoint::extension_create<NetPointNs3>();
ns3_initialize(ns3_tcp_model.get().c_str());
if (surf_network_model)
return;
surf_network_model = new simgrid::kernel::resource::NetworkSmpiModel();
- all_existing_models.push_back(surf_network_model);
simgrid::config::set_default<double>("network/weight-S", 8775);
}
NetworkSmpiModel::NetworkSmpiModel() : NetworkCm02Model()
{
+ /* Do not add this into all_existing_models: our ancestor already does so */
}
NetworkSmpiModel::~NetworkSmpiModel() = default;
void surf_storage_model_init_default()
{
surf_storage_model = new simgrid::surf::StorageN11Model();
- all_existing_models.push_back(surf_storage_model);
}
namespace simgrid {
namespace surf {
+StorageN11Model::StorageN11Model()
+{
+ all_existing_models.push_back(this);
+}
+
StorageImpl* StorageN11Model::createStorage(std::string id, std::string type_id, std::string content_name,
std::string attach)
{
class StorageN11Model : public StorageModel {
public:
+ StorageN11Model();
StorageImpl* createStorage(std::string id, std::string type_id, std::string content_name,
std::string attach) override;
double next_occuring_event(double now) override;