for (const auto&kv : mounts) {
const char* mountpoint = kv.first.c_str();
- simgrid::s4u::Storage &storage = *kv.second;
+ simgrid::s4u::Storage storage = *kv.second;
// Retrieve disk's information
sg_size_t free_size = storage.sizeFree();
write = file->write(100000); // Write 100,000 bytes
XBT_INFO("Write %llu bytes on %s", write, filename);
- simgrid::s4u::Storage &storage = simgrid::s4u::Storage::byName("Disk4");
+ simgrid::s4u::Storage* storage = simgrid::s4u::Storage::byName("Disk4");
// Now rename file from ./tmp/data.txt to ./tmp/simgrid.readme
const char *newpath = "/home/tmp/simgrid.readme";
delete file;
// Now attach some user data to disk1
- XBT_INFO("Get/set data for storage element: %s",storage.name());
- XBT_INFO(" Uninitialized storage data: '%s'", (char*)storage.userdata());
+ XBT_INFO("Get/set data for storage element: %s", storage->name());
+ XBT_INFO(" Uninitialized storage data: '%s'", (char*)storage->userdata());
- storage.setUserdata(xbt_strdup("Some user data"));
- XBT_INFO(" Set and get data: '%s'", (char*)storage.userdata());
+ storage->setUserdata(xbt_strdup("Some user data"));
+ XBT_INFO(" Set and get data: '%s'", (char*)storage->userdata());
- xbt_free(storage.userdata());
+ xbt_free(storage->userdata());
}
};
namespace simgrid {
namespace s4u {
+std::map<std::string, Storage*>* allStorages();
+
XBT_PUBLIC_CLASS Storage
{
friend s4u::Engine;
-
- Storage(std::string name, smx_storage_t inferior);
+ friend simgrid::surf::StorageImpl;
public:
- Storage() = default;
- virtual ~Storage();
+ explicit Storage(surf::StorageImpl * pimpl) : pimpl_(pimpl) {}
+ virtual ~Storage() = default;
/** Retrieve a Storage by its name. It must exist in the platform file */
- static Storage& byName(const char* name);
+ static Storage* byName(const char* name);
const char* name();
const char* host();
sg_size_t sizeFree();
const char* property(const char* key);
void setProperty(const char* key, char* value);
std::map<std::string, sg_size_t*>* content();
- std::unordered_map<std::string, Storage*>* allStorages();
-
-protected:
- smx_storage_t inferior();
public:
void setUserdata(void* data) { userdata_ = data; }
void* userdata() { return userdata_; }
-private:
- static std::unordered_map<std::string, Storage*>* storages_;
+ /* The signals */
+ /** @brief Callback signal fired when a new Link is created */
+ static simgrid::xbt::signal<void(s4u::Storage&)> onCreation;
+
+ /** @brief Callback signal fired when a Link is destroyed */
+ static simgrid::xbt::signal<void(s4u::Storage&)> onDestruction;
- std::string hostname_;
+private:
std::string name_;
- sg_size_t size_ = 0;
- smx_storage_t pimpl_ = nullptr;
+ surf::StorageImpl* const pimpl_ = nullptr;
void* userdata_ = nullptr;
};
void Engine::shutdown() {
delete s4u::Engine::instance_;
s4u::Engine::instance_ = nullptr;
- delete s4u::Storage::storages_;
}
double Engine::getClock()
char *mountname;
char *storagename;
xbt_dict_foreach(dict, cursor, mountname, storagename) {
- mounts->insert({mountname, &Storage::byName(storagename)});
+ mounts->insert({mountname, Storage::byName(storagename)});
}
xbt_dict_free(&dict);
}
#include "xbt/lib.h"
#include <unordered_map>
-extern xbt_lib_t storage_lib;
-
namespace simgrid {
namespace s4u {
-
-std::unordered_map<std::string, Storage*>* Storage::storages_ = new std::unordered_map<std::string, Storage*>();
-
-Storage::Storage(std::string name, smx_storage_t inferior) :
- name_(name), pimpl_(inferior)
+std::map<std::string, Storage*>* allStorages()
{
- hostname_ = surf_storage_get_host(pimpl_);
- size_ = surf_storage_get_size(pimpl_);
- storages_->insert({name, this});
-}
+ std::unordered_map<std::string, surf::StorageImpl*>* map = surf::StorageImpl::storagesMap();
+ std::map<std::string, Storage*>* res = new std::map<std::string, Storage*>;
+ for (auto s : *map)
+ res->insert({s.first, &(s.second->piface_)}); // Convert each entry into its interface
-Storage::~Storage() = default;
-
-smx_storage_t Storage::inferior()
-{
- return pimpl_;
+ return res;
}
-Storage& Storage::byName(const char* name)
+Storage* Storage::byName(const char* name)
{
- s4u::Storage* res = nullptr;
- try {
- res = storages_->at(name);
- } catch (std::out_of_range& e) {
- smx_storage_t inferior = xbt_lib_get_elm_or_null(storage_lib,name);
- if (inferior == nullptr)
- xbt_die("Storage %s does not exist. Please only use the storages that are defined in your platform.", name);
-
- res = new Storage(name,inferior);
- }
- return *res;
+ surf::StorageImpl* res = surf::StorageImpl::byName(name);
+ if (res == nullptr)
+ return nullptr;
+ return &res->piface_;
}
const char* Storage::name()
{
- return name_.c_str();
+ return pimpl_->cname();
}
const char* Storage::host()
{
- return hostname_.c_str();
+ return pimpl_->attach_;
}
sg_size_t Storage::sizeFree()
{
- return simgrid::simix::kernelImmediate([this] { return surf_storage_resource_priv(pimpl_)->getFreeSize(); });
+ return simgrid::simix::kernelImmediate([this] { return pimpl_->getFreeSize(); });
}
sg_size_t Storage::sizeUsed()
{
- return simgrid::simix::kernelImmediate([this] { return surf_storage_resource_priv(pimpl_)->getUsedSize(); });
+ return simgrid::simix::kernelImmediate([this] { return pimpl_->getUsedSize(); });
}
sg_size_t Storage::size() {
- return size_;
+ return pimpl_->size_;
}
xbt_dict_t Storage::properties()
{
- return simcall_storage_get_properties(pimpl_);
+ return simgrid::simix::kernelImmediate([this] { return pimpl_->getProperties(); });
}
const char* Storage::property(const char* key)
std::map<std::string, sg_size_t*>* Storage::content()
{
- return simgrid::simix::kernelImmediate([this] { return surf_storage_resource_priv(this->pimpl_)->getContent(); });
+ return simgrid::simix::kernelImmediate([this] { return pimpl_->getContent(); });
}
-std::unordered_map<std::string, Storage*>* Storage::allStorages()
-{
- return storages_;
-}
+/*************
+ * Callbacks *
+ *************/
+simgrid::xbt::signal<void(s4u::Storage&)> Storage::onCreation;
+simgrid::xbt::signal<void(s4u::Storage&)> Storage::onDestruction;
} /* namespace s4u */
} /* namespace simgrid */
simgrid::xbt::signal<void(StorageImpl*, int, int)> storageStateChangedCallbacks; // signature: wasOn, isOn
simgrid::xbt::signal<void(StorageAction*, Action::State, Action::State)> storageActionStateChangedCallbacks;
+/* List of storages */
+std::unordered_map<std::string, StorageImpl*>* StorageImpl::storages =
+ new std::unordered_map<std::string, StorageImpl*>();
+
+StorageImpl* StorageImpl::byName(const char* name)
+{
+ if (storages->find(name) == storages->end())
+ return nullptr;
+ return storages->at(name);
+}
+
/*********
* Model *
*********/
StorageImpl::StorageImpl(Model* model, const char* name, lmm_system_t maxminSystem, double bread, double bwrite,
const char* type_id, const char* content_name, sg_size_t size, const char* attach)
: Resource(model, name, lmm_constraint_new(maxminSystem, this, MAX(bread, bwrite)))
+ , piface_(this)
, size_(size)
, usedSize_(0)
, typeId_(xbt_strdup(type_id))
XBT_DEBUG("Create resource with Bread '%f' Bwrite '%f' and Size '%llu'", bread, bwrite, size);
constraintRead_ = lmm_constraint_new(maxminSystem, this, bread);
constraintWrite_ = lmm_constraint_new(maxminSystem, this, bwrite);
+ storages->insert({name, this});
}
StorageImpl::~StorageImpl()
#include <xbt/base.h>
#include <xbt/signal.hpp>
+#include "simgrid/s4u/Storage.hpp"
#include "src/surf/PropertyHolder.hpp"
#include "surf_interface.hpp"
#include <map>
StorageImpl(Model* model, const char* name, lmm_system_t maxminSystem, double bread, double bwrite,
const char* type_id, const char* content_name, sg_size_t size, const char* attach);
- ~StorageImpl();
+ ~StorageImpl() override;
+
+public:
+ /** @brief Public interface */
+ s4u::Storage piface_;
+ static StorageImpl* byName(const char* name);
/** @brief Check if the Storage is used (if an action currently uses its resources) */
bool isUsed() override;
virtual sg_size_t getUsedSize();
std::map<std::string, sg_size_t*>* parseContent(const char* filename);
-
+ static std::unordered_map<std::string, StorageImpl*>* storages;
+ static std::unordered_map<std::string, StorageImpl*>* storagesMap() { return StorageImpl::storages; }
std::vector<StorageAction*> writeActions_;
lmm_constraint_t constraintWrite_; /* Constraint for maximum write bandwidth*/
*********/
namespace simgrid {
- namespace surf {
-
- class NetworkCm02Model : public NetworkModel {
- public:
- NetworkCm02Model();
- explicit NetworkCm02Model(void (*solve_fun)(lmm_system_t self));
- virtual ~NetworkCm02Model() = default;
- LinkImpl* createLink(const char* name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy) override;
- void updateActionsStateLazy(double now, double delta) override;
- void updateActionsStateFull(double now, double delta) override;
- Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
- virtual void gapAppend(double size, const LinkImpl* link, NetworkAction* action);
-
- protected:
- bool haveGap_ = false;
- };
-
- /************
- * Resource *
- ************/
-
- class NetworkCm02Link : public LinkImpl {
- public:
- NetworkCm02Link(NetworkCm02Model* model, const char* name, double bandwidth, double latency,
- e_surf_link_sharing_policy_t policy, lmm_system_t system);
- virtual ~NetworkCm02Link() = default;
- void apply_event(tmgr_trace_event_t event, double value) override;
- void setBandwidth(double value) override;
- void setLatency(double value) override;
- virtual void gapAppend(double size, const LinkImpl* link, NetworkAction* action);
- };
-
-
- /**********
- * Action *
- **********/
- class NetworkCm02Action : public NetworkAction {
- friend Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate);
- friend NetworkSmpiModel;
- public:
- NetworkCm02Action(Model *model, double cost, bool failed)
- : NetworkAction(model, cost, failed) {};
- virtual ~NetworkCm02Action() = default;
- void updateRemainingLazy(double now) override;
- protected:
- double senderGap_;
- };
-
- }
+namespace surf {
+
+class NetworkCm02Model : public NetworkModel {
+public:
+ NetworkCm02Model();
+ explicit NetworkCm02Model(void (*solve_fun)(lmm_system_t self));
+ virtual ~NetworkCm02Model() = default;
+ LinkImpl* createLink(const char* name, double bandwidth, double latency,
+ e_surf_link_sharing_policy_t policy) override;
+ void updateActionsStateLazy(double now, double delta) override;
+ void updateActionsStateFull(double now, double delta) override;
+ Action* communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) override;
+ virtual void gapAppend(double size, const LinkImpl* link, NetworkAction* action);
+
+protected:
+ bool haveGap_ = false;
+};
+
+/************
+ * Resource *
+ ************/
+
+class NetworkCm02Link : public LinkImpl {
+public:
+ NetworkCm02Link(NetworkCm02Model* model, const char* name, double bandwidth, double latency,
+ e_surf_link_sharing_policy_t policy, lmm_system_t system);
+ virtual ~NetworkCm02Link() = default;
+ void apply_event(tmgr_trace_event_t event, double value) override;
+ void setBandwidth(double value) override;
+ void setLatency(double value) override;
+ virtual void gapAppend(double size, const LinkImpl* link, NetworkAction* action);
+};
+
+/**********
+ * Action *
+ **********/
+class NetworkCm02Action : public NetworkAction {
+ friend Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate);
+ friend NetworkSmpiModel;
+
+public:
+ NetworkCm02Action(Model* model, double cost, bool failed) : NetworkAction(model, cost, failed){};
+ virtual ~NetworkCm02Action() = default;
+ void updateRemainingLazy(double now) override;
+
+protected:
+ double senderGap_;
+};
+}
}
#endif /* SURF_NETWORK_CM02_HPP_ */
: StorageImpl(model, name, maxminSystem, bread, bwrite, type_id, content_name, size, attach)
{
XBT_DEBUG("Create resource with Bread '%f' Bwrite '%f' and Size '%llu'", bread, bwrite, size);
+ simgrid::s4u::Storage::onCreation(this->piface_);
}
StorageAction *StorageN11::open(const char* mount, const char* path)
public:
StorageN11(StorageModel* model, const char* name, lmm_system_t maxminSystem, double bread, double bwrite,
const char* type_id, char* content_name, sg_size_t size, char* attach);
+ virtual ~StorageN11() = default;
StorageAction *open(const char* mount, const char* path);
StorageAction *close(surf_file_t fd);
StorageAction *ls(const char *path);
XBT_PUBLIC(void) surf_parse_set_debug(int bdebug);
XBT_PUBLIC(int) surf_parse_lex_destroy();
-/* To include files (?) */
-XBT_PRIVATE void surfxml_bufferstack_push(int _new);
-XBT_PRIVATE void surfxml_bufferstack_pop(int _new);
-XBT_PUBLIC_DATA(int) surfxml_bufferstack_size;
-
XBT_PUBLIC(void) routing_route_free(sg_platf_route_cbarg_t route);
/********** Instr. **********/
XBT_PRIVATE void sg_instr_new_router(const char* name);
SG_BEGIN_DECL()
-/*
- * Allow the cluster tag to mess with the parsing buffer.
- * (this will probably become obsolete once the cluster tag do not mess with the parsing callbacks directly)
- */
-
-/* This buffer is used to store the original buffer before substituting it by out own buffer. Useful for the cluster tag */
-static std::vector<char*> surfxml_bufferstack_stack;
-int surfxml_bufferstack_size = 2048;
-
-static char *old_buff = nullptr;
-
-XBT_IMPORT_NO_EXPORT(unsigned int) surfxml_buffer_stack_stack_ptr;
-XBT_IMPORT_NO_EXPORT(unsigned int) surfxml_buffer_stack_stack[1024];
-
-void surfxml_bufferstack_push(int new_one)
-{
- if (not new_one)
- old_buff = surfxml_bufferstack;
- else {
- surfxml_bufferstack_stack.push_back(surfxml_bufferstack);
- surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size);
- }
-}
-
-void surfxml_bufferstack_pop(int new_one)
-{
- if (not new_one)
- surfxml_bufferstack = old_buff;
- else {
- free(surfxml_bufferstack);
- surfxml_bufferstack = surfxml_bufferstack_stack.back();
- surfxml_bufferstack_stack.pop_back();
- }
-}
-
-/*
- * Trace related stuff
- */
+/* Trace related stuff */
xbt_dict_t traces_set_list = nullptr;
-XBT_PRIVATE xbt_dict_t trace_connect_list_host_avail = nullptr;
-XBT_PRIVATE xbt_dict_t trace_connect_list_host_speed = nullptr;
-XBT_PRIVATE xbt_dict_t trace_connect_list_link_avail = nullptr;
-XBT_PRIVATE xbt_dict_t trace_connect_list_link_bw = nullptr;
-XBT_PRIVATE xbt_dict_t trace_connect_list_link_lat = nullptr;
+XBT_PRIVATE std::unordered_map<std::string, std::string> trace_connect_list_host_avail;
+XBT_PRIVATE std::unordered_map<std::string, std::string> trace_connect_list_host_speed;
+XBT_PRIVATE std::unordered_map<std::string, std::string> trace_connect_list_link_avail;
+XBT_PRIVATE std::unordered_map<std::string, std::string> trace_connect_list_link_bw;
+XBT_PRIVATE std::unordered_map<std::string, std::string> trace_connect_list_link_lat;
void sg_platf_trace_connect(sg_platf_trace_connect_cbarg_t trace_connect)
{
xbt_assert(xbt_dict_get_or_null(traces_set_list, trace_connect->trace),
- "Cannot connect trace %s to %s: trace unknown",
- trace_connect->trace,
- trace_connect->element);
+ "Cannot connect trace %s to %s: trace unknown", trace_connect->trace, trace_connect->element);
switch (trace_connect->kind) {
case SURF_TRACE_CONNECT_KIND_HOST_AVAIL:
- xbt_dict_set(trace_connect_list_host_avail,
- trace_connect->trace,
- xbt_strdup(trace_connect->element), nullptr);
+ trace_connect_list_host_avail.insert({trace_connect->trace, trace_connect->element});
break;
case SURF_TRACE_CONNECT_KIND_SPEED:
- xbt_dict_set(trace_connect_list_host_speed, trace_connect->trace,
- xbt_strdup(trace_connect->element), nullptr);
+ trace_connect_list_host_speed.insert({trace_connect->trace, trace_connect->element});
break;
case SURF_TRACE_CONNECT_KIND_LINK_AVAIL:
- xbt_dict_set(trace_connect_list_link_avail,
- trace_connect->trace,
- xbt_strdup(trace_connect->element), nullptr);
+ trace_connect_list_link_avail.insert({trace_connect->trace, trace_connect->element});
break;
case SURF_TRACE_CONNECT_KIND_BANDWIDTH:
- xbt_dict_set(trace_connect_list_link_bw,
- trace_connect->trace,
- xbt_strdup(trace_connect->element), nullptr);
+ trace_connect_list_link_bw.insert({trace_connect->trace, trace_connect->element});
break;
case SURF_TRACE_CONNECT_KIND_LATENCY:
- xbt_dict_set(trace_connect_list_link_lat, trace_connect->trace,
- xbt_strdup(trace_connect->element), nullptr);
+ trace_connect_list_link_lat.insert({trace_connect->trace, trace_connect->element});
break;
default:
- surf_parse_error("Cannot connect trace %s to %s: kind of trace unknown",
- trace_connect->trace, trace_connect->element);
+ surf_parse_error("Cannot connect trace %s to %s: kind of trace unknown", trace_connect->trace,
+ trace_connect->element);
break;
}
}
-
-/* ***************************************** */
-
static int after_config_done;
void parse_after_config() {
if (not after_config_done) {
int parse_status;
/* init the flex parser */
- surfxml_buffer_stack_stack_ptr = 1;
- surfxml_buffer_stack_stack[0] = 0;
after_config_done = 0;
surf_parse_open(file);
traces_set_list = xbt_dict_new_homogeneous(nullptr);
- trace_connect_list_host_avail = xbt_dict_new_homogeneous(free);
- trace_connect_list_host_speed = xbt_dict_new_homogeneous(free);
- trace_connect_list_link_avail = xbt_dict_new_homogeneous(free);
- trace_connect_list_link_bw = xbt_dict_new_homogeneous(free);
- trace_connect_list_link_lat = xbt_dict_new_homogeneous(free);
/* Do the actual parsing */
parse_status = surf_parse();
/* connect all traces relative to hosts */
- xbt_dict_cursor_t cursor = nullptr;
- char* trace_name;
- char* elm;
+ for (auto elm : trace_connect_list_host_avail) {
+ tmgr_trace_t trace = (tmgr_trace_t)xbt_dict_get_or_null(traces_set_list, elm.first.c_str());
+ xbt_assert(trace, "Trace %s undefined", elm.first.c_str());
- xbt_dict_foreach(trace_connect_list_host_avail, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- xbt_assert(trace, "Trace %s undefined", trace_name);
-
- simgrid::s4u::Host *host = sg_host_by_name(elm);
- xbt_assert(host, "Host %s undefined", elm);
+ simgrid::s4u::Host* host = sg_host_by_name(elm.second.c_str());
+ xbt_assert(host, "Host %s undefined", elm.second.c_str());
simgrid::surf::Cpu *cpu = host->pimpl_cpu;
cpu->setStateTrace(trace);
}
- xbt_dict_foreach(trace_connect_list_host_speed, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- xbt_assert(trace, "Trace %s undefined", trace_name);
- simgrid::s4u::Host *host = sg_host_by_name(elm);
- xbt_assert(host, "Host %s undefined", elm);
+ for (auto elm : trace_connect_list_host_speed) {
+ tmgr_trace_t trace = (tmgr_trace_t)xbt_dict_get_or_null(traces_set_list, elm.first.c_str());
+ xbt_assert(trace, "Trace %s undefined", elm.first.c_str());
+
+ simgrid::s4u::Host* host = sg_host_by_name(elm.second.c_str());
+ xbt_assert(host, "Host %s undefined", elm.second.c_str());
simgrid::surf::Cpu *cpu = host->pimpl_cpu;
cpu->setSpeedTrace(trace);
}
- xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- xbt_assert(trace, "Trace %s undefined", trace_name);
- sg_link_t link = simgrid::s4u::Link::byName(elm);
- xbt_assert(link, "Link %s undefined", elm);
+
+ for (auto elm : trace_connect_list_link_avail) {
+ tmgr_trace_t trace = (tmgr_trace_t)xbt_dict_get_or_null(traces_set_list, elm.first.c_str());
+ xbt_assert(trace, "Trace %s undefined", elm.first.c_str());
+
+ sg_link_t link = simgrid::s4u::Link::byName(elm.second.c_str());
+ xbt_assert(link, "Link %s undefined", elm.second.c_str());
link->setStateTrace(trace);
}
- xbt_dict_foreach(trace_connect_list_link_bw, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- xbt_assert(trace, "Trace %s undefined", trace_name);
- sg_link_t link = simgrid::s4u::Link::byName(elm);
- xbt_assert(link, "Link %s undefined", elm);
+ for (auto elm : trace_connect_list_link_bw) {
+ tmgr_trace_t trace = (tmgr_trace_t)xbt_dict_get_or_null(traces_set_list, elm.first.c_str());
+ xbt_assert(trace, "Trace %s undefined", elm.first.c_str());
+ sg_link_t link = simgrid::s4u::Link::byName(elm.second.c_str());
+ xbt_assert(link, "Link %s undefined", elm.second.c_str());
link->setBandwidthTrace(trace);
}
- xbt_dict_foreach(trace_connect_list_link_lat, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- xbt_assert(trace, "Trace %s undefined", trace_name);
- sg_link_t link = simgrid::s4u::Link::byName(elm);
- xbt_assert(link, "Link %s undefined", elm);
+ for (auto elm : trace_connect_list_link_lat) {
+ tmgr_trace_t trace = (tmgr_trace_t)xbt_dict_get_or_null(traces_set_list, elm.first.c_str());
+ xbt_assert(trace, "Trace %s undefined", elm.first.c_str());
+ sg_link_t link = simgrid::s4u::Link::byName(elm.second.c_str());
+ xbt_assert(link, "Link %s undefined", elm.second.c_str());
link->setLatencyTrace(trace);
}
/* Free my data */
- xbt_dict_free(&trace_connect_list_host_avail);
- xbt_dict_free(&trace_connect_list_host_speed);
- xbt_dict_free(&trace_connect_list_link_avail);
- xbt_dict_free(&trace_connect_list_link_bw);
- xbt_dict_free(&trace_connect_list_link_lat);
xbt_dict_free(&traces_set_list);
surf_parse_close();
static void dump_storage_by_name(char* name)
{
XBT_INFO("*** Dump a storage element ***");
- simgrid::s4u::Storage& storage = simgrid::s4u::Storage::byName(name);
- display_storage_content(&storage);
+ simgrid::s4u::Storage* storage = simgrid::s4u::Storage::byName(name);
+ display_storage_content(storage);
}
static void get_set_storage_data(const char* storage_name)
{
XBT_INFO("*** GET/SET DATA for storage element: %s ***", storage_name);
- simgrid::s4u::Storage& storage = simgrid::s4u::Storage::byName(storage_name);
+ simgrid::s4u::Storage* storage = simgrid::s4u::Storage::byName(storage_name);
- char* data = static_cast<char*>(storage.userdata());
+ char* data = static_cast<char*>(storage->userdata());
XBT_INFO("Get data: '%s'", data);
- storage.setUserdata(xbt_strdup("Some data"));
- data = static_cast<char*>(storage.userdata());
+ storage->setUserdata(xbt_strdup("Some data"));
+ data = static_cast<char*>(storage->userdata());
XBT_INFO("\tSet and get data: '%s'", data);
xbt_free(data);
}
static void dump_platform_storages()
{
- std::unordered_map<std::string, simgrid::s4u::Storage*>* storages = simgrid::s4u::Storage().allStorages();
+ std::map<std::string, simgrid::s4u::Storage*>* storages = simgrid::s4u::allStorages();
for (auto storage : *storages) {
XBT_INFO("Storage %s is attached to %s", storage.first.c_str(), storage.second->host());
storage.second->setProperty("other usage", xbt_strdup("gpfs"));
}
- // Expected output in tesh file that's missing for now
- //> [ 1.207952] (server@alice) Storage Disk3 is attached to carl
- //> [ 1.207952] (server@alice) Storage Disk4 is attached to denise
+ delete storages;
}
static void storage_info(simgrid::s4u::Host* host)
xbt_dict_t storage_list = host->mountedStoragesAsDict();
xbt_dict_foreach (storage_list, cursor, mount_name, storage_name) {
XBT_INFO("\tStorage name: %s, mount name: %s", storage_name, mount_name);
- simgrid::s4u::Storage& storage = simgrid::s4u::Storage::byName(storage_name);
+ simgrid::s4u::Storage* storage = simgrid::s4u::Storage::byName(storage_name);
- sg_size_t free_size = storage.sizeFree();
- sg_size_t used_size = storage.sizeUsed();
+ sg_size_t free_size = storage->sizeFree();
+ sg_size_t used_size = storage->sizeUsed();
XBT_INFO("\t\tFree size: %llu bytes", free_size);
XBT_INFO("\t\tUsed size: %llu bytes", used_size);
- display_storage_properties(&storage);
+ display_storage_properties(storage);
dump_storage_by_name(storage_name);
}
xbt_dict_free(&storage_list);
> [ 1.207952] (server@alice) \Windows\write.exe size: 10752 bytes
> [ 1.207952] (server@alice) Storage Disk1 is attached to bob
> [ 1.207952] (server@alice) Storage Disk2 is attached to alice
+> [ 1.207952] (server@alice) Storage Disk3 is attached to carl
+> [ 1.207952] (server@alice) Storage Disk4 is attached to denise
> [ 1.207952] (maestro@) Simulated time: 1.20795