X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/281f8c29e177852dcb1591fc31e363e1176857c8..fe06d3ceaa02056b708bb777ed9973df6744f776:/src/surf/network_constant.cpp diff --git a/src/surf/network_constant.cpp b/src/surf/network_constant.cpp index 13fff27765..0ebd1813df 100644 --- a/src/surf/network_constant.cpp +++ b/src/surf/network_constant.cpp @@ -1,168 +1,100 @@ +/* Copyright (c) 2013-2018. The SimGrid Team. All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + #include "network_constant.hpp" -#include "surf/random_mgr.h" +#include "src/surf/surf_interface.hpp" +#include "surf/surf.hpp" XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network); -static int host_number_int = 0; - -static void netcste_count_hosts(sg_platf_host_cbarg_t h) { - host_number_int++; -} /********* * Model * *********/ void surf_network_model_init_Constant() { - xbt_assert(surf_network_model == NULL); - surf_network_model = new NetworkConstantModel(); + xbt_assert(surf_network_model == nullptr); + surf_network_model = new simgrid::kernel::resource::NetworkConstantModel(); +} - sg_platf_host_add_cb(netcste_count_hosts); +namespace simgrid { +namespace kernel { +namespace resource { +NetworkConstantModel::NetworkConstantModel() : NetworkModel(Model::UpdateAlgo::FULL) +{ + all_existing_models.push_back(this); +} - ModelPtr model = static_cast(surf_network_model); - xbt_dynar_push(model_list, &model); +LinkImpl* NetworkConstantModel::create_link(const std::string& name, double bw, double lat, + s4u::Link::SharingPolicy policy) +{ - routing_model_create(NULL); + xbt_die("Refusing to create the link %s: there is no link in the Constant network model. " + "Please remove any link from your platform (and switch to routing='None')", + name.c_str()); + return nullptr; } -double NetworkConstantModel::shareResources(double now) +double NetworkConstantModel::next_occuring_event(double /*now*/) { - void *_action = NULL; - NetworkConstantActionLmmPtr action = NULL; double min = -1.0; - - xbt_swag_foreach(_action, p_runningActionSet) { - action = dynamic_cast(static_cast(_action)); - if (action->m_latency > 0) { - if (min < 0) - min = action->m_latency; - else if (action->m_latency < min) - min = action->m_latency; - } + for (kernel::resource::Action const& action : *get_started_action_set()) { + const NetworkConstantAction& net_action = static_cast(action); + if (net_action.latency_ > 0 && (min < 0 || net_action.latency_ < min)) + min = net_action.latency_; } - return min; } -void NetworkConstantModel::updateActionsState(double now, double delta) +void NetworkConstantModel::update_actions_state(double /*now*/, double delta) { - void *_action, *_next_action; - NetworkConstantActionLmmPtr action = NULL; - - xbt_swag_foreach_safe(_action, _next_action, p_runningActionSet) { - action = dynamic_cast(static_cast(_action)); - if (action->m_latency > 0) { - if (action->m_latency > delta) { - double_update(&(action->m_latency), delta); + for (auto it = std::begin(*get_started_action_set()); it != std::end(*get_started_action_set());) { + NetworkConstantAction& action = static_cast(*it); + ++it; // increment iterator here since the following calls to action.finish() may invalidate it + if (action.latency_ > 0) { + if (action.latency_ > delta) { + double_update(&action.latency_, delta, sg_surf_precision); } else { - action->m_latency = 0.0; + action.latency_ = 0.0; } } - double_update(&(action->m_remains), - action->m_cost * delta / action->m_latInit); - if (action->m_maxDuration != NO_MAX_DURATION) - double_update(&(action->m_maxDuration), delta); + action.update_remains(action.get_cost() * delta / action.initialLatency_); + if (action.get_max_duration() != NO_MAX_DURATION) + action.update_max_duration(delta); - if (action->m_remains <= 0) { - action->m_finish = surf_get_clock(); - action->setState(SURF_ACTION_DONE); - } else if ((action->m_maxDuration != NO_MAX_DURATION) - && (action->m_maxDuration <= 0)) { - action->m_finish = surf_get_clock(); - action->setState(SURF_ACTION_DONE); + if ((action.get_remains_no_update() <= 0) || + ((action.get_max_duration() != NO_MAX_DURATION) && (action.get_max_duration() <= 0))) { + action.finish(kernel::resource::Action::State::FINISHED); } } } -ActionPtr NetworkConstantModel::communicate(RoutingEdgePtr src, RoutingEdgePtr dst, - double size, double rate) +kernel::resource::Action* NetworkConstantModel::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) { - char *src_name = src->p_name; - char *dst_name = dst->p_name; - - XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate); - NetworkConstantActionLmmPtr action = new NetworkConstantActionLmm(this, sg_latency_factor); - XBT_OUT(); + NetworkConstantAction* action = new NetworkConstantAction(this, size, sg_latency_factor); + simgrid::s4u::Link::on_communicate(action, src, dst); return action; } -/************ - * Resource * - ************/ -bool NetworkConstantLinkLmm::isUsed() -{ - return 0; -} - -void NetworkConstantLinkLmm::updateState(tmgr_trace_event_t event_type, - double value, double time) -{ - DIE_IMPOSSIBLE; -} - -double NetworkConstantLinkLmm::getBandwidth() -{ - DIE_IMPOSSIBLE; - return -1.0; /* useless since DIE actually abort(), but eclipse prefer to have a useless and harmless return */ -} - -double NetworkConstantLinkLmm::getLatency() -{ - DIE_IMPOSSIBLE; - return -1.0; /* useless since DIE actually abort(), but eclipse prefer to have a useless and harmless return */ -} - -bool NetworkConstantLinkLmm::isShared() -{ - DIE_IMPOSSIBLE; - return -1; /* useless since DIE actually abort(), but eclipse prefer to have a useless and harmless return */ -} - /********** * Action * **********/ - -int NetworkConstantActionLmm::unref() -{ - m_refcount--; - if (!m_refcount) { - xbt_swag_remove(static_cast(this), p_stateSet); - delete this; - return 1; - } - return 0; -} - -void NetworkConstantActionLmm::cancel() +NetworkConstantAction::NetworkConstantAction(NetworkConstantModel* model_, double size, double latency) + : NetworkAction(model_, size, false), initialLatency_(latency) { - return; -} + latency_ = latency; + if (latency_ <= 0.0) + NetworkConstantAction::set_state(Action::State::FINISHED); +}; -#ifdef HAVE_TRACING -void NetworkConstantActionLmm::setCategory(const char *category) -{ - //ignore completely the categories in constant model, they are not traced -} -#endif +NetworkConstantAction::~NetworkConstantAction() = default; -void NetworkConstantActionLmm::suspend() +void NetworkConstantAction::update_remains_lazy(double /*now*/) { - m_suspended = true; + THROW_IMPOSSIBLE; } - -void NetworkConstantActionLmm::resume() -{ - if (m_suspended) - m_suspended = false; } - -void NetworkConstantActionLmm::recycle() -{ - return; +} // namespace kernel } - -bool NetworkConstantActionLmm::isSuspended() -{ - return m_suspended; -} -