/** @brief take into account changes of speed (either load or max) */
void CpuCas01::on_speed_change()
{
- lmm::Variable* var = nullptr;
+ const lmm::Variable* var;
const lmm::Element* elem = nullptr;
get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(),
get_host()->turn_on();
}
} else {
- lmm::Constraint* cnst = get_constraint();
- lmm::Variable* var = nullptr;
+ const lmm::Constraint* cnst = get_constraint();
+ const lmm::Variable* var;
const lmm::Element* elem = nullptr;
double date = surf_get_clock();
if (sg_weight_S_parameter > 0) {
double delta = sg_weight_S_parameter / value - sg_weight_S_parameter / (bandwidth_.peak * bandwidth_.scale);
- kernel::lmm::Variable* var;
+ const kernel::lmm::Variable* var;
const kernel::lmm::Element* elem = nullptr;
const kernel::lmm::Element* nextelem = nullptr;
int numelem = 0;
void NetworkCm02Link::set_latency(double value)
{
double delta = value - latency_.peak;
- kernel::lmm::Variable* var = nullptr;
+ const kernel::lmm::Variable* var;
const kernel::lmm::Element* elem = nullptr;
const kernel::lmm::Element* nextelem = nullptr;
int numelem = 0;
try {
Be = std::stod(radical_elements.front());
- } catch (std::invalid_argument& ia) {
+ } catch (const std::invalid_argument& ia) {
throw std::invalid_argument(std::string("First part of smpi/IB-penalty-factors is not numerical:") + ia.what());
}
try {
Bs = std::stod(radical_elements.at(1));
- } catch (std::invalid_argument& ia) {
+ } catch (const std::invalid_argument& ia) {
throw std::invalid_argument(std::string("Second part of smpi/IB-penalty-factors is not numerical:") + ia.what());
}
try {
ys = std::stod(radical_elements.back());
- } catch (std::invalid_argument& ia) {
+ } catch (const std::invalid_argument& ia) {
throw std::invalid_argument(std::string("Third part of smpi/IB-penalty-factors is not numerical:") + ia.what());
}
}
Resource::turn_off();
s4u::Link::on_state_change(this->piface_);
- kernel::lmm::Variable* var = nullptr;
+ const kernel::lmm::Variable* var;
const kernel::lmm::Element* elem = nullptr;
double now = surf_get_clock();
while ((var = get_constraint()->get_variable(&elem))) {
/* Need to check that none of the model has failed */
int i = 0;
- kernel::lmm::Constraint* cnst = action.get_variable()->get_constraint(i);
+ const kernel::lmm::Constraint* cnst = action.get_variable()->get_constraint(i);
while (cnst != nullptr) {
i++;
- kernel::resource::Resource* constraint_id = cnst->get_id();
+ const kernel::resource::Resource* constraint_id = cnst->get_id();
if (not constraint_id->is_on()) {
XBT_DEBUG("Action (%p) Failed!!", &action);
action.finish(kernel::resource::Action::State::FAILED);
kernel::resource::Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
{
std::vector<s4u::Host*> host_list = {src, dst};
- double* flops_amount = new double[2]();
+ const double* flops_amount = new double[2]();
double* bytes_amount = new double[4]();
bytes_amount[1] = size;
/** @brief take into account changes of speed (either load or max) */
void CpuL07::on_speed_change()
{
- kernel::lmm::Variable* var = nullptr;
+ const kernel::lmm::Variable* var;
const kernel::lmm::Element* elem = nullptr;
get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(), speed_.peak * speed_.scale);
while ((var = get_constraint()->get_variable(&elem))) {
- kernel::resource::Action* action = static_cast<kernel::resource::Action*>(var->get_id());
+ const kernel::resource::Action* action = static_cast<kernel::resource::Action*>(var->get_id());
get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), speed_.scale * speed_.peak);
}
void LinkL07::set_latency(double value)
{
- kernel::lmm::Variable* var = nullptr;
+ const kernel::lmm::Variable* var;
L07Action *action;
const kernel::lmm::Element* elem = nullptr;
// other columns are to store one or more link for the node
//add a loopback link
- simgrid::s4u::Link* linkUp = nullptr;
- simgrid::s4u::Link* linkDown = nullptr;
+ const simgrid::s4u::Link* linkUp = nullptr;
+ const simgrid::s4u::Link* linkDown = nullptr;
if(cluster->loopback_bw > 0 || cluster->loopback_lat > 0){
std::string tmp_link = link_id + "_loopback";
XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", tmp_link.c_str(), cluster->loopback_bw);
xbt_assert(std::find(known_storages.begin(), known_storages.end(), storage->id) == known_storages.end(),
"Refusing to add a second storage named \"%s\"", storage->id.c_str());
- simgrid::kernel::resource::StorageType* stype;
+ const simgrid::kernel::resource::StorageType* stype;
auto st = storage_types.find(storage->type_id);
if (st != storage_types.end()) {
stype = st->second;
}
xbt_die("%s", msg.c_str());
}
- simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(actor->function);
+ const simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(actor->function);
xbt_assert(factory, "Error while creating an actor from the XML file: Function '%s' not registered", actor->function);
double start_time = actor->start_time;
xbt_assert(dynamic_cast<simgrid::kernel::routing::ClusterZone*>(current_routing),
"Only hosts from Cluster and Vivaldi ASes can get a host_link.");
- simgrid::s4u::Link* linkUp = simgrid::s4u::Link::by_name_or_null(hostlink->link_up);
- simgrid::s4u::Link* linkDown = simgrid::s4u::Link::by_name_or_null(hostlink->link_down);
+ const simgrid::s4u::Link* linkUp = simgrid::s4u::Link::by_name_or_null(hostlink->link_up);
+ const simgrid::s4u::Link* linkDown = simgrid::s4u::Link::by_name_or_null(hostlink->link_down);
xbt_assert(linkUp, "Link '%s' not found!", hostlink->link_up.c_str());
xbt_assert(linkDown, "Link '%s' not found!", hostlink->link_down.c_str());
void check_disk_attachment()
{
for (auto const& s : simgrid::s4u::Engine::get_instance()->get_all_storages()) {
- simgrid::kernel::routing::NetPoint* host_elm =
+ const simgrid::kernel::routing::NetPoint* host_elm =
simgrid::s4u::Engine::get_instance()->netpoint_by_name_or_null(s->get_impl()->get_host());
if (not host_elm)
surf_parse_error(std::string("Unable to attach storage ") + s->get_cname() + ": host " +
StorageImpl* StorageN11Model::createStorage(const std::string& id, const std::string& type_id,
const std::string& content_name, const std::string& attach)
{
- StorageType* storage_type = storage_types.at(type_id);
+ const StorageType* storage_type = storage_types.at(type_id);
double Bread =
surf_parse_get_bandwidth(storage_type->model_properties->at("Bread").c_str(), "property Bread, storage", type_id);
{
simgrid::s4u::Engine::shutdown();
for (auto const& e : storage_types) {
- simgrid::kernel::resource::StorageType* stype = e.second;
+ const simgrid::kernel::resource::StorageType* stype = e.second;
delete stype->properties;
delete stype->model_properties;
delete stype;