/* 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 "src/portable.h"
+#include "src/internal_config.h"
#include "surf_private.h"
#include "surf_interface.hpp"
#include "network_interface.hpp"
surf_network_model_init_IB},
{"CM02", "Legacy network analytic model (Very similar to LV08, but without corrective factors. The timings of small messages are thus poorly modeled).",
surf_network_model_init_CM02},
-#ifdef HAVE_NS3
+#if HAVE_NS3
{"NS3", "Network pseudo-model using the NS3 tcp model instead of an analytic model", surf_network_model_init_NS3},
#endif
{"Reno", "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-#ifdef HAVE_THREAD_CONTEXTS
+#if HAVE_THREAD_CONTEXTS
static xbt_parmap_t surf_parmap = NULL; /* parallel map on models */
#endif
return NOW;
}
-#ifdef _XBT_WIN32
+#ifdef _WIN32
# define FILE_DELIM "\\"
#else
# define FILE_DELIM "/" /* FIXME: move to better location */
return NULL;
}
-#ifdef _XBT_WIN32
+#ifdef _WIN32
#include <windows.h>
#define MAX_DRIVE 26
static const char *disk_drives_letter_table[MAX_DRIVE] = {
const char *__surf_get_initial_path(void)
{
-#ifdef _XBT_WIN32
+#ifdef _WIN32
unsigned i;
char current_directory[MAX_PATH + 1] = { 0 };
unsigned int len = GetCurrentDirectory(MAX_PATH + 1, current_directory);
*/
int __surf_is_absolute_file_path(const char *file_path)
{
-#ifdef _XBT_WIN32
+#ifdef _WIN32
WIN32_FIND_DATA wfd = { 0 };
HANDLE hFile = FindFirstFile(file_path, &wfd);
return -1;
}
-static XBT_INLINE void surf_storage_free(void *r)
+static inline void surf_storage_free(void *r)
{
delete static_cast<simgrid::surf::Storage*>(r);
}
void surf_init(int *argc, char **argv)
{
+ if (host_list != nullptr) // Already initialized
+ return;
+
XBT_DEBUG("Create all Libs");
host_list = xbt_dict_new_homogeneous([](void*p) {
simgrid::s4u::Host* host = static_cast<simgrid::s4u::Host*>(p);
future_evt_set = nullptr;
}
-#ifdef HAVE_THREAD_CONTEXTS
+#if HAVE_THREAD_CONTEXTS
xbt_parmap_destroy(surf_parmap);
#endif
namespace surf {
Model::Model()
- : p_maxminSystem(NULL)
+ : maxminSystem_(NULL)
{
- p_readyActionSet = new ActionList();
- p_runningActionSet = new ActionList();
- p_failedActionSet = new ActionList();
- p_doneActionSet = new ActionList();
+ readyActionSet_ = new ActionList();
+ runningActionSet_ = new ActionList();
+ failedActionSet_ = new ActionList();
+ doneActionSet_ = new ActionList();
- p_modifiedSet = NULL;
- p_actionHeap = NULL;
- p_updateMechanism = UM_UNDEFINED;
- m_selectiveUpdate = 0;
+ modifiedSet_ = NULL;
+ actionHeap_ = NULL;
+ updateMechanism_ = UM_UNDEFINED;
+ selectiveUpdate_ = 0;
}
Model::~Model(){
- delete p_readyActionSet;
- delete p_runningActionSet;
- delete p_failedActionSet;
- delete p_doneActionSet;
+ delete readyActionSet_;
+ delete runningActionSet_;
+ delete failedActionSet_;
+ delete doneActionSet_;
}
double Model::next_occuring_event(double now)
{
//FIXME: set the good function once and for all
- if (p_updateMechanism == UM_LAZY)
+ if (updateMechanism_ == UM_LAZY)
return next_occuring_event_lazy(now);
- else if (p_updateMechanism == UM_FULL)
+ else if (updateMechanism_ == UM_FULL)
return next_occuring_event_full(now);
else
xbt_die("Invalid cpu update mechanism!");
XBT_DEBUG
("Before share resources, the size of modified actions set is %zd",
- p_modifiedSet->size());
+ modifiedSet_->size());
- lmm_solve(p_maxminSystem);
+ lmm_solve(maxminSystem_);
XBT_DEBUG
("After share resources, The size of modified actions set is %zd",
- p_modifiedSet->size());
+ modifiedSet_->size());
- while(!p_modifiedSet->empty()) {
- action = &(p_modifiedSet->front());
- p_modifiedSet->pop_front();
+ while(!modifiedSet_->empty()) {
+ action = &(modifiedSet_->front());
+ modifiedSet_->pop_front();
int max_dur_flag = 0;
- if (action->getStateSet() != p_runningActionSet)
+ if (action->getStateSet() != runningActionSet_)
continue;
/* bogus priority, skip it */
action->getMaxDuration());
if (min != -1) {
- action->heapUpdate(p_actionHeap, min, max_dur_flag ? MAX_DURATION : NORMAL);
+ action->heapUpdate(actionHeap_, min, max_dur_flag ? MAX_DURATION : NORMAL);
XBT_DEBUG("Insert at heap action(%p) min %f now %f", action, min,
now);
} else DIE_IMPOSSIBLE;
}
//hereafter must have already the min value for this resource model
- if (xbt_heap_size(p_actionHeap) > 0)
- min = xbt_heap_maxkey(p_actionHeap) - now;
+ if (xbt_heap_size(actionHeap_) > 0)
+ min = xbt_heap_maxkey(actionHeap_) - now;
else
min = -1;
void Model::updateActionsState(double now, double delta)
{
- if (p_updateMechanism == UM_FULL)
+ if (updateMechanism_ == UM_FULL)
updateActionsStateFull(now, delta);
- else if (p_updateMechanism == UM_LAZY)
+ else if (updateMechanism_ == UM_LAZY)
updateActionsStateLazy(now, delta);
else
xbt_die("Invalid cpu update mechanism!");
{}
Resource::Resource(Model *model, const char *name, lmm_constraint_t constraint, int initiallyOn)
- : p_name(xbt_strdup(name))
- , p_model(model)
- , m_isOn(initiallyOn)
- , p_constraint(constraint)
+ : name_(xbt_strdup(name))
+ , model_(model)
+ , isOn_(initiallyOn)
+ , constraint_(constraint)
{}
Resource::Resource(Model *model, const char *name, int initiallyOn)
- : p_name(xbt_strdup(name))
- , p_model(model)
- , m_isOn(initiallyOn)
+ : name_(xbt_strdup(name))
+ , model_(model)
+ , isOn_(initiallyOn)
{}
Resource::~Resource() {
- xbt_free((void*)p_name);
+ xbt_free((void*)name_);
}
bool Resource::isOn() {
- return m_isOn;
+ return isOn_;
}
bool Resource::isOff() {
- return ! m_isOn;
+ return ! isOn_;
}
void Resource::turnOn()
{
- if (!m_isOn) {
- m_isOn = true;
+ if (!isOn_) {
+ isOn_ = true;
}
}
void Resource::turnOff()
{
- if (m_isOn) {
- m_isOn = false;
+ if (isOn_) {
+ isOn_ = false;
}
}
-Model *Resource::getModel() {
- return p_model;
+Model *Resource::getModel() const {
+ return model_;
+}
+
+const char *Resource::getName() const {
+ return name_;
}
-const char *Resource::getName() {
- return p_name;
+bool Resource::operator==(const Resource &other) const {
+ return strcmp(name_, other.name_);
}
lmm_constraint_t Resource::getConstraint() {
- return p_constraint;
+ return constraint_;
}
}
m_finish = surf_get_clock();
}
-e_surf_action_state_t Action::getState()
+Action::State Action::getState()
{
if (p_stateSet == getModel()->getReadyActionSet())
- return SURF_ACTION_READY;
+ return Action::State::ready;
if (p_stateSet == getModel()->getRunningActionSet())
- return SURF_ACTION_RUNNING;
+ return Action::State::running;
if (p_stateSet == getModel()->getFailedActionSet())
- return SURF_ACTION_FAILED;
+ return Action::State::failed;
if (p_stateSet == getModel()->getDoneActionSet())
- return SURF_ACTION_DONE;
- return SURF_ACTION_NOT_IN_THE_SYSTEM;
+ return Action::State::done;
+ return Action::State::not_in_the_system;
}
-void Action::setState(e_surf_action_state_t state)
+void Action::setState(Action::State state)
{
- //surf_action_state_t action_state = &(action->model_type->states);
- XBT_IN("(%p,%s)", this, surf_action_state_names[state]);
p_stateSet->erase(p_stateSet->iterator_to(*this));
- if (state == SURF_ACTION_READY)
+ switch (state) {
+ case Action::State::ready:
p_stateSet = getModel()->getReadyActionSet();
- else if (state == SURF_ACTION_RUNNING)
+ break;
+ case Action::State::running:
p_stateSet = getModel()->getRunningActionSet();
- else if (state == SURF_ACTION_FAILED)
+ break;
+ case Action::State::failed:
p_stateSet = getModel()->getFailedActionSet();
- else if (state == SURF_ACTION_DONE)
+ break;
+ case Action::State::done:
p_stateSet = getModel()->getDoneActionSet();
- else
+ break;
+ default:
p_stateSet = NULL;
-
+ break;
+ }
if (p_stateSet)
p_stateSet->push_back(*this);
- XBT_OUT();
}
double Action::getBound()
}
void Action::cancel(){
- setState(SURF_ACTION_FAILED);
+ setState(Action::State::failed);
if (getModel()->getUpdateMechanism() == UM_LAZY) {
if (action_lmm_hook.is_linked())
getModel()->getModifiedSet()->erase(getModel()->getModifiedSet()->iterator_to(*this));
if ((m_remains <= 0) &&
(lmm_get_variable_weight(getVariable()) > 0)) {
finish();
- setState(SURF_ACTION_DONE);
+ setState(Action::State::done);
heapRemove(getModel()->getActionHeap());
} else if (((m_maxDuration != NO_MAX_DURATION)
&& (m_maxDuration <= 0))) {
finish();
- setState(SURF_ACTION_DONE);
+ setState(Action::State::done);
heapRemove(getModel()->getActionHeap());
}
}
