namespace surf {
HostL07Model::HostL07Model() : HostModel() {
- maxminSystem_ = lmm_system_new(1);
+ maxminSystem_ = lmm_system_new(true /* lazy */);
maxminSystem_->solve_fun = &bottleneck_solve;
surf_network_model = new NetworkL07Model(this,maxminSystem_);
surf_cpu_model_pm = new CpuL07Model(this,maxminSystem_);
CpuL07Model::CpuL07Model(HostL07Model *hmodel,lmm_system_t sys)
: CpuModel()
- , p_hostModel(hmodel)
+ , hostModel_(hmodel)
{
maxminSystem_ = sys;
}
}
NetworkL07Model::NetworkL07Model(HostL07Model *hmodel, lmm_system_t sys)
: NetworkModel()
- , p_hostModel(hmodel)
+ , hostModel_(hmodel)
{
maxminSystem_ = sys;
}
}
-double HostL07Model::next_occuring_event(double now)
+double HostL07Model::nextOccuringEvent(double now)
{
- double min = HostModel::next_occuring_event_full(now);
+ double min = HostModel::nextOccuringEventFull(now);
for (auto it(getRunningActionSet()->begin()), itend(getRunningActionSet()->end()); it != itend ; ++it) {
L07Action *action = static_cast<L07Action*>(&*it);
- if (action->m_latency > 0 && (min < 0 || action->m_latency < min)) {
- min = action->m_latency;
+ if (action->latency_ > 0 && (min < 0 || action->latency_ < min)) {
+ min = action->latency_;
XBT_DEBUG("Updating min with %p (start %f): %f", action, action->getStartTime(), min);
}
}
; it = itNext) {
++itNext;
action = static_cast<L07Action*>(&*it);
- if (action->m_latency > 0) {
- if (action->m_latency > delta) {
- double_update(&(action->m_latency), delta, sg_surf_precision);
+ 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;
}
- if ((action->m_latency == 0.0) && (action->isSuspended() == 0)) {
+ if ((action->latency_ == 0.0) && (action->isSuspended() == 0)) {
action->updateBound();
lmm_update_variable_weight(maxminSystem_, action->getVariable(), 1.0);
}
int nb_used_host = 0; /* Only the hosts with something to compute (>0 flops) are counted) */
double latency = 0.0;
- this->p_netcardList->reserve(host_nb);
+ this->netcardList_->reserve(host_nb);
for (int i = 0; i<host_nb; i++)
- this->p_netcardList->push_back(host_list[i]->pimpl_netcard);
+ this->netcardList_->push_back(host_list[i]->pimpl_netcard);
/* Compute the number of affected resources... */
if(bytes_amount != nullptr) {
double lat=0.0;
std::vector<Link*> *route = new std::vector<Link*>();
- routing_platf->getRouteAndLatency((*p_netcardList)[i], (*p_netcardList)[j], route, &lat);
+ routing_platf->getRouteAndLatency((*netcardList_)[i], (*netcardList_)[j], route, &lat);
latency = MAX(latency, lat);
for (auto link : *route)
nb_used_host++;
XBT_DEBUG("Creating a parallel task (%p) with %d hosts and %d unique links.", this, host_nb, nb_link);
- this->p_computationAmount = flops_amount;
- this->p_communicationAmount = bytes_amount;
- this->m_latency = latency;
- this->m_rate = rate;
+ this->computationAmount_ = flops_amount;
+ this->communicationAmount_ = bytes_amount;
+ this->latency_ = latency;
+ this->rate_ = rate;
this->variable_ = lmm_variable_new(model->getMaxminSystem(), this, 1.0,
(rate > 0 ? rate : -1.0),
host_nb + nb_link);
- if (this->m_latency > 0)
+ if (this->latency_ > 0)
lmm_update_variable_weight(model->getMaxminSystem(), this->getVariable(), 0.0);
for (int i = 0; i < host_nb; i++)
continue;
std::vector<Link*> *route = new std::vector<Link*>();
- routing_platf->getRouteAndLatency((*p_netcardList)[i], (*p_netcardList)[j], route, nullptr);
+ routing_platf->getRouteAndLatency((*netcardList_)[i], (*netcardList_)[j], route, nullptr);
for (auto link : *route)
lmm_expand_add(model->getMaxminSystem(), link->getConstraint(), this->getVariable(), bytes_amount[i * host_nb + j]);
xbt_free(host_list);
}
-Action *NetworkL07Model::communicate(kernel::routing::NetCard *src, kernel::routing::NetCard *dst, double size, double rate)
+Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
{
sg_host_t*host_list = xbt_new0(sg_host_t, 2);
double *flops_amount = xbt_new0(double, 2);
double *bytes_amount = xbt_new0(double, 4);
- host_list[0] = sg_host_by_name(src->name());
- host_list[1] = sg_host_by_name(dst->name());
+ host_list[0] = src;
+ host_list[1] = dst;
bytes_amount[1] = size;
- return p_hostModel->executeParallelTask(2, host_list, flops_amount, bytes_amount, rate);
+ return hostModel_->executeParallelTask(2, host_list, flops_amount, bytes_amount, rate);
}
Cpu *CpuL07Model::createCpu(simgrid::s4u::Host *host, std::vector<double> *speedPerPstate, int core)
host_list[0] = getHost();
flops_amount[0] = size;
- return static_cast<CpuL07Model*>(getModel())->p_hostModel->executeParallelTask(1, host_list, flops_amount, nullptr, -1);
+ return static_cast<CpuL07Model*>(getModel())->hostModel_->executeParallelTask(1, host_list, flops_amount, nullptr, -1);
}
Action *CpuL07::sleep(double duration)
**********/
L07Action::~L07Action(){
- delete p_netcardList;
- free(p_communicationAmount);
- free(p_computationAmount);
+ delete netcardList_;
+ free(communicationAmount_);
+ free(computationAmount_);
}
void L07Action::updateBound()
double lat_bound = -1.0;
int i, j;
- int hostNb = p_netcardList->size();
+ int hostNb = netcardList_->size();
- if (p_communicationAmount != nullptr) {
+ if (communicationAmount_ != nullptr) {
for (i = 0; i < hostNb; i++) {
for (j = 0; j < hostNb; j++) {
- if (p_communicationAmount[i * hostNb + j] > 0) {
+ if (communicationAmount_[i * hostNb + j] > 0) {
double lat = 0.0;
std::vector<Link*> *route = new std::vector<Link*>();
- routing_platf->getRouteAndLatency((*p_netcardList)[i], (*p_netcardList)[j], route, &lat);
+ routing_platf->getRouteAndLatency((*netcardList_)[i], (*netcardList_)[j], route, &lat);
- lat_current = MAX(lat_current, lat * p_communicationAmount[i * hostNb + j]);
+ lat_current = MAX(lat_current, lat * communicationAmount_[i * hostNb + j]);
delete route;
}
}
}
lat_bound = sg_tcp_gamma / (2.0 * lat_current);
XBT_DEBUG("action (%p) : lat_bound = %g", this, lat_bound);
- if ((m_latency == 0.0) && (suspended_ == 0)) {
- if (m_rate < 0)
+ if ((latency_ == 0.0) && (suspended_ == 0)) {
+ if (rate_ < 0)
lmm_update_variable_bound(getModel()->getMaxminSystem(), getVariable(), lat_bound);
else
- lmm_update_variable_bound(getModel()->getMaxminSystem(), getVariable(), std::min(m_rate, lat_bound));
+ lmm_update_variable_bound(getModel()->getMaxminSystem(), getVariable(), std::min(rate_, lat_bound));
}
}