A
lgorithmique
N
umérique
D
istribuée
Public GIT Repository
projects
/
simgrid.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
| inline |
side by side
say bye to simgrid::surf namespace
[simgrid.git]
/
src
/
surf
/
ptask_L07.cpp
diff --git
a/src/surf/ptask_L07.cpp
b/src/surf/ptask_L07.cpp
index
351bca8
..
bd0f778
100644
(file)
--- a/
src/surf/ptask_L07.cpp
+++ b/
src/surf/ptask_L07.cpp
@@
-23,22
+23,23
@@
void surf_host_model_init_ptask_L07()
{
XBT_CINFO(xbt_cfg, "Switching to the L07 model to handle parallel tasks.");
- auto host_model = std::make_shared<simgrid::
surf
::HostL07Model>("Host_Ptask");
+ auto host_model = std::make_shared<simgrid::
kernel::resource
::HostL07Model>("Host_Ptask");
auto* engine = simgrid::kernel::EngineImpl::get_instance();
engine->add_model(host_model);
engine->get_netzone_root()->set_host_model(host_model);
}
namespace simgrid {
-namespace surf {
+namespace kernel {
+namespace resource {
HostL07Model::HostL07Model(const std::string& name) : HostModel(name)
{
- auto* maxmin_system = new
simgrid::kernel::
lmm::FairBottleneck(true /* selective update */);
+ auto* maxmin_system = new lmm::FairBottleneck(true /* selective update */);
set_maxmin_system(maxmin_system);
auto net_model = std::make_shared<NetworkL07Model>("Network_Ptask", this, maxmin_system);
- auto engine =
simgrid::kernel::
EngineImpl::get_instance();
+ auto engine = EngineImpl::get_instance();
engine->add_model(net_model);
engine->get_netzone_root()->set_network_model(net_model);
@@
-47,7
+48,7
@@
HostL07Model::HostL07Model(const std::string& name) : HostModel(name)
engine->get_netzone_root()->set_cpu_pm_model(cpu_model);
}
-CpuL07Model::CpuL07Model(const std::string& name, HostL07Model* hmodel,
kernel::
lmm::System* sys)
+CpuL07Model::CpuL07Model(const std::string& name, HostL07Model* hmodel, lmm::System* sys)
: CpuModel(name), hostModel_(hmodel)
{
set_maxmin_system(sys);
@@
-58,7
+59,7
@@
CpuL07Model::~CpuL07Model()
set_maxmin_system(nullptr);
}
-NetworkL07Model::NetworkL07Model(const std::string& name, HostL07Model* hmodel,
kernel::
lmm::System* sys)
+NetworkL07Model::NetworkL07Model(const std::string& name, HostL07Model* hmodel, lmm::System* sys)
: NetworkModel(name), hostModel_(hmodel)
{
set_maxmin_system(sys);
@@
-76,7
+77,7
@@
NetworkL07Model::~NetworkL07Model()
double HostL07Model::next_occurring_event(double now)
{
double min = HostModel::next_occurring_event_full(now);
- for (
kernel::resource::
Action const& action : *get_started_action_set()) {
+ for (Action const& action : *get_started_action_set()) {
const auto& net_action = static_cast<const L07Action&>(action);
if (net_action.get_latency() > 0 && (min < 0 || net_action.get_latency() < min)) {
min = net_action.get_latency();
@@
-119,19
+120,19
@@
void HostL07Model::update_actions_state(double /*now*/, double delta)
if (((action.get_remains() <= 0) && (action.get_variable()->get_penalty() > 0)) ||
((action.get_max_duration() != NO_MAX_DURATION) && (action.get_max_duration() <= 0))) {
- action.finish(
kernel::resource::
Action::State::FINISHED);
+ action.finish(Action::State::FINISHED);
continue;
}
/* Need to check that none of the model has failed */
int i = 0;
- const
kernel::lmm::Constraint* cnst
= action.get_variable()->get_constraint(i);
+ const
lmm::Constraint* cnst
= action.get_variable()->get_constraint(i);
while (cnst != nullptr) {
i++;
- const
kernel::resource::
Resource* constraint_id = cnst->get_id();
+ const 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);
+ action.finish(Action::State::FAILED);
break;
}
cnst = action.get_variable()->get_constraint(i);
@@
-139,15
+140,14
@@
void HostL07Model::update_actions_state(double /*now*/, double delta)
}
}
-kernel::resource::CpuAction* HostL07Model::execute_parallel(const std::vector<s4u::Host*>& host_list,
- const double* flops_amount, const double* bytes_amount,
- double rate)
+CpuAction* HostL07Model::execute_parallel(const std::vector<s4u::Host*>& host_list, const double* flops_amount,
+ const double* bytes_amount, double rate)
{
return new L07Action(this, host_list, flops_amount, bytes_amount, rate);
}
-L07Action::L07Action(
kernel::resource::Model* model, const std::vector<s4u::Host*>& host_lis
t,
- const double*
flops_amount, const double*
bytes_amount, double rate)
+L07Action::L07Action(
Model* model, const std::vector<s4u::Host*>& host_list, const double* flops_amoun
t,
+ const double* bytes_amount, double rate)
: CpuAction(model, 1.0, false), computationAmount_(flops_amount), communicationAmount_(bytes_amount), rate_(rate)
{
size_t link_nb = 0;
@@
-169,7
+169,7
@@
L07Action::L07Action(kernel::resource::Model* model, const std::vector<s4u::Host
continue;
double lat = 0.0;
- std::vector<
kernel::resource::
LinkImpl*> route;
+ std::vector<LinkImpl*> route;
hostList_[k / host_list.size()]->route_to(hostList_[k % host_list.size()], route, &lat);
latency = std::max(latency, lat);
@@
-206,7
+206,7
@@
L07Action::L07Action(kernel::resource::Model* model, const std::vector<s4u::Host
for (size_t k = 0; k < host_list.size() * host_list.size(); k++) {
if (bytes_amount[k] <= 0.0)
continue;
- std::vector<
kernel::resource::
LinkImpl*> route;
+ std::vector<LinkImpl*> route;
hostList_[k / host_list.size()]->route_to(hostList_[k % host_list.size()], route, nullptr);
for (auto const& link : route)
@@
-220,7
+220,7
@@
L07Action::L07Action(kernel::resource::Model* model, const std::vector<s4u::Host
}
}
-
kernel::resource::
Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
+Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
{
std::vector<s4u::Host*> host_list = {src, dst};
const auto* flops_amount = new double[2]();
@@
-228,17
+228,17
@@
kernel::resource::Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host
bytes_amount[1] = size;
-
kernel::resource::
Action* res = hostModel_->execute_parallel(host_list, flops_amount, bytes_amount, rate);
+ Action* res = hostModel_->execute_parallel(host_list, flops_amount, bytes_amount, rate);
static_cast<L07Action*>(res)->free_arrays_ = true;
return res;
}
-
kernel::resource::
CpuImpl* CpuL07Model::create_cpu(s4u::Host* host, const std::vector<double>& speed_per_pstate)
+CpuImpl* CpuL07Model::create_cpu(s4u::Host* host, const std::vector<double>& speed_per_pstate)
{
return (new CpuL07(host, speed_per_pstate))->set_model(this);
}
-
kernel::resource::
LinkImpl* NetworkL07Model::create_link(const std::string& name, const std::vector<double>& bandwidths)
+LinkImpl* NetworkL07Model::create_link(const std::string& name, const std::vector<double>& bandwidths)
{
xbt_assert(bandwidths.size() == 1, "Non WIFI link must have only 1 bandwidth.");
auto link = new LinkL07(name, bandwidths[0], get_maxmin_system());
@@
-246,8
+246,7
@@
kernel::resource::LinkImpl* NetworkL07Model::create_link(const std::string& name
return link;
}
-kernel::resource::LinkImpl* NetworkL07Model::create_wifi_link(const std::string& name,
- const std::vector<double>& bandwidths)
+LinkImpl* NetworkL07Model::create_wifi_link(const std::string& name, const std::vector<double>& bandwidths)
{
THROW_UNIMPLEMENTED;
}
@@
-256,7
+255,7
@@
kernel::resource::LinkImpl* NetworkL07Model::create_wifi_link(const std::string&
* Resource *
************/
-
kernel::resource::
CpuAction* CpuL07::execution_start(double size, double user_bound)
+CpuAction* CpuL07::execution_start(double size, double user_bound)
{
std::vector<s4u::Host*> host_list = {get_iface()};
xbt_assert(user_bound <= 0, "User bound not supported by ptask model");
@@
-264,17
+263,17
@@
kernel::resource::CpuAction* CpuL07::execution_start(double size, double user_bo
auto* flops_amount = new double[host_list.size()]();
flops_amount[0] = size;
-
kernel::resource::
CpuAction* res =
+ CpuAction* res =
static_cast<CpuL07Model*>(get_model())->hostModel_->execute_parallel(host_list, flops_amount, nullptr, -1);
static_cast<L07Action*>(res)->free_arrays_ = true;
return res;
}
-
kernel::resource::
CpuAction* CpuL07::sleep(double duration)
+CpuAction* CpuL07::sleep(double duration)
{
auto* action = static_cast<L07Action*>(execution_start(1.0, -1));
action->set_max_duration(duration);
- action->set_suspend_state(
kernel::resource::
Action::SuspendStates::SLEEPING);
+ action->set_suspend_state(Action::SuspendStates::SLEEPING);
get_model()->get_maxmin_system()->update_variable_penalty(action->get_variable(), 0.0);
return action;
@@
-283,11
+282,11
@@
kernel::resource::CpuAction* CpuL07::sleep(double duration)
/** @brief take into account changes of speed (either load or max) */
void CpuL07::on_speed_change()
{
- const
kernel::
lmm::Element* elem = nullptr;
+ const lmm::Element* elem = nullptr;
get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(), speed_.peak * speed_.scale);
while (const auto* var = get_constraint()->get_variable(&elem)) {
- const
kernel::resource::
Action* action = var->get_id();
+ const Action* action = var->get_id();
get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), speed_.scale * speed_.peak);
}
@@
-295,13
+294,13
@@
void CpuL07::on_speed_change()
CpuImpl::on_speed_change();
}
-LinkL07::LinkL07(const std::string& name, double bandwidth,
kernel::
lmm::System* system) : LinkImpl(name)
+LinkL07::LinkL07(const std::string& name, double bandwidth, lmm::System* system) : LinkImpl(name)
{
this->set_constraint(system->constraint_new(this, bandwidth));
bandwidth_.peak = bandwidth;
}
-void CpuL07::apply_event(
kernel::
profile::Event* triggered, double value)
+void CpuL07::apply_event(profile::Event* triggered, double value)
{
XBT_DEBUG("Updating cpu %s (%p) with value %g", get_cname(), this, value);
if (triggered == speed_.event) {
@@
-324,7
+323,7
@@
void CpuL07::apply_event(kernel::profile::Event* triggered, double value)
}
}
-void LinkL07::apply_event(
kernel::
profile::Event* triggered, double value)
+void LinkL07::apply_event(profile::Event* triggered, double value)
{
XBT_DEBUG("Updating link %s (%p) with value=%f", get_cname(), this, value);
if (triggered == bandwidth_.event) {
@@
-357,7
+356,7
@@
void LinkL07::set_bandwidth(double value)
void LinkL07::set_latency(double value)
{
latency_check(value);
- const
kernel::
lmm::Element* elem = nullptr;
+ const lmm::Element* elem = nullptr;
latency_.peak = value;
while (const auto* var = get_constraint()->get_variable(&elem)) {
@@
-390,7
+389,7
@@
void L07Action::updateBound()
for (size_t j = 0; j < host_count; j++) {
if (communicationAmount_[i * host_count + j] > 0) {
double lat = 0.0;
- std::vector<
kernel::resource::
LinkImpl*> route;
+ std::vector<LinkImpl*> route;
hostList_.at(i)->route_to(hostList_.at(j), route, &lat);
lat_current = std::max(lat_current, lat * communicationAmount_[i * host_count + j]);
@@
-398,7
+397,7
@@
void L07Action::updateBound()
}
}
}
- double lat_bound =
kernel::resource::
NetworkModel::cfg_tcp_gamma / (2.0 * lat_current);
+ double lat_bound = NetworkModel::cfg_tcp_gamma / (2.0 * lat_current);
XBT_DEBUG("action (%p) : lat_bound = %g", this, lat_bound);
if ((latency_ <= 0.0) && is_running()) {
if (rate_ < 0)
@@
-408,5
+407,6
@@
void L07Action::updateBound()
}
}
-} // namespace surf
+} // namespace resource
+} // namespace kernel
} // namespace simgrid