-/* Copyright (c) 2004-2016. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2017. 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 "src/surf/surf_private.h"
#include "surf/surf.h"
-#include "surf/surf_routing.h"
#include "xbt/str.h"
#include <boost/intrusive/list.hpp>
+#include <set>
#include <string>
+#include <unordered_map>
#define NO_MAX_DURATION -1.0
/* user-visible parameters */
extern XBT_PRIVATE double sg_tcp_gamma;
-extern XBT_PRIVATE double sg_sender_gap;
extern XBT_PRIVATE double sg_latency_factor;
extern XBT_PRIVATE double sg_bandwidth_factor;
extern XBT_PRIVATE double sg_weight_S_parameter;
extern XBT_PRIVATE int sg_network_crosstraffic;
-extern XBT_PRIVATE xbt_dynar_t surf_path;
+extern XBT_PRIVATE std::vector<std::string> surf_path;
+extern XBT_PRIVATE std::unordered_map<std::string, tmgr_trace_t> traces_set_list;
+extern XBT_PRIVATE std::set<std::string> watched_hosts;
extern "C" {
-XBT_PUBLIC(double) surf_get_clock(void);
+XBT_PUBLIC(double) surf_get_clock();
}
/** \ingroup SURF_simulation
* \brief List of hosts that have just restarted and whose autorestart process should be restarted.
*/
XBT_PUBLIC_DATA(std::vector<sg_host_t>) host_that_restart;
-
-extern XBT_PRIVATE double sg_sender_gap;
-
namespace simgrid {
namespace surf {
-extern XBT_PRIVATE simgrid::xbt::signal<void(void)> surfExitCallbacks;
-
+extern XBT_PRIVATE simgrid::xbt::signal<void()> surfExitCallbacks;
}
}
int XBT_PRIVATE __surf_is_absolute_file_path(const char *file_path);
-static inline char* sg_storage_name(sg_storage_t storage) {
- return storage->key;
-}
-
/***********
* Classes *
***********/
NOTSET
};
-/*********
- * Trace *
- *********/
-/* For the trace and trace:connect tag (store their content till the end of the parsing) */
-XBT_PUBLIC_DATA(xbt_dict_t) traces_set_list;
-
/**********
* Action *
**********/
not_in_the_system /**< Not in the system anymore. Why did you ask ? */
};
-public:
/**
* @brief Action constructor
*
/** @brief Destructor */
virtual ~Action();
- /** @brief Mark that the action is now finished */
- void finish();
+ /**
+ * @brief Mark that the action is now finished
+ *
+ * @param state the new [state](\ref simgrid::surf::Action::State) of the current Action
+ */
+ void finish(Action::State state);
/** @brief Get the [state](\ref simgrid::surf::Action::State) of the current Action */
Action::State getState(); /**< get the state*/
void setCategory(const char *category);
/** @brief Get the priority of the current Action */
- double getPriority() {return priority_;};
+ double getPriority() { return sharingWeight_; };
/** @brief Set the priority of the current Action */
- virtual void setPriority(double priority);
+ virtual void setSharingWeight(double priority);
/** @brief Get the state set in which the action is */
ActionList* getStateSet() {return stateSet_;};
s_xbt_swag_hookup_t stateHookup_ = {nullptr,nullptr};
- simgrid::surf::Model *getModel() {return model_;}
+ simgrid::surf::Model* getModel() { return model_; }
protected:
ActionList* stateSet_;
- double priority_ = 1.0; /**< priority (1.0 by default) */
+ double sharingWeight_ = 1.0; /**< priority (1.0 by default) */
int refcount_ = 1;
double remains_; /**< How much of that cost remains to be done in the currently running task */
double maxDuration_ = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */
/* LMM */
public:
- virtual void updateRemainingLazy(double now);
+ virtual void updateRemainingLazy(double now) { THROW_IMPOSSIBLE; };
void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat);
void heapRemove(xbt_heap_t heap);
void heapUpdate(xbt_heap_t heap, double key, enum heap_action_type hat);
- void updateIndexHeap(int i);
+ virtual void updateIndexHeap(int i);
lmm_variable_t getVariable() {return variable_;}
double getLastUpdate() {return lastUpdate_;}
void refreshLastUpdate() {lastUpdate_ = surf_get_clock();}
enum heap_action_type getHat() {return hat_;}
bool is_linked() {return action_lmm_hook.is_linked();}
- void gapRemove();
protected:
lmm_variable_t variable_ = nullptr;
typedef struct {
double peak; /**< The peak of the metric, ie its max value */
double scale; /**< Current availability of the metric according to the traces, in [0,1] */
- tmgr_trace_iterator_t event; /**< The associated trace event associated to the metric */
+ tmgr_trace_event_t event; /**< The associated trace event associated to the metric */
} s_surf_metric_t;
namespace simgrid {
* @param name The name of the Resource
* @param constraint The lmm constraint associated to this Resource if it is part of a LMM component
*/
- Resource(Model *model, const char *name, lmm_constraint_t constraint);
+ Resource(Model * model, const std::string& name, lmm_constraint_t constraint);
virtual ~Resource();
* @param event What happened
* @param value [TODO]
*/
- virtual void apply_event(tmgr_trace_iterator_t event, double value)=0;
+ virtual void apply_event(tmgr_trace_event_t event, double value) = 0;
/** @brief Check if the current Resource is used (if it currently serves an action) */
virtual bool isUsed()=0;
}
namespace std {
- template <>
- struct hash<simgrid::surf::Resource>
- {
- std::size_t operator()(const simgrid::surf::Resource& r) const
- {
- return (std::size_t) xbt_str_hash(r.cname());
- }
+template <> class hash<simgrid::surf::Resource> {
+public:
+ std::size_t operator()(const simgrid::surf::Resource& r) const { return (std::size_t)xbt_str_hash(r.cname()); }
};
}
