-/* Copyright (c) 2015-2019. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2015-2020. 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/HostImpl.hpp"
#include "src/surf/xml/platf_private.hpp"
#include "xbt/config.hpp"
+#include "xbt/parse_units.hpp"
#include <algorithm>
#include <boost/algorithm/string.hpp>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_file, s4u, "S4U files");
int sg_storage_max_file_descriptors = 1024;
-/** @defgroup plugin_filesystem
- @beginrst
-
- @endrst
+/** @defgroup plugin_filesystem Plugin FileSystem
+ *
+ * This adds the notion of Files on top of the storage notion that provided by the core of SimGrid.
+ * Activate this plugin at will.
*/
-
namespace simgrid {
+
+template class xbt::Extendable<s4u::File>;
+
namespace s4u {
simgrid::xbt::Extension<Disk, FileSystemDiskExt> FileSystemDiskExt::EXTENSION_ID;
simgrid::xbt::Extension<Storage, FileSystemStorageExt> FileSystemStorageExt::EXTENSION_ID;
return st;
}
-Disk* File::find_local_disk_on(Host* host)
+Disk* File::find_local_disk_on(const Host* host)
{
Disk* d = nullptr;
size_t longest_prefix_length = 0;
File::File(const std::string& fullpath, sg_host_t host, void* userdata) : fullpath_(fullpath)
{
- this->set_data(userdata);
- // this cannot fail because we get a xbt_die if the mountpoint does not exist
- if (not host->get_mounted_storages().empty()) {
- local_storage_ = find_local_storage_on(host);
- }
- if (not host->get_disks().empty()) {
- local_disk_ = find_local_disk_on(host);
- }
+ kernel::actor::simcall([this, &host, userdata] {
+ this->set_data(userdata);
+ // this cannot fail because we get a xbt_die if the mountpoint does not exist
+ if (not host->get_mounted_storages().empty()) {
+ local_storage_ = find_local_storage_on(host);
+ }
+ if (not host->get_disks().empty()) {
+ local_disk_ = find_local_disk_on(host);
+ }
- // assign a file descriptor id to the newly opened File
- FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
- if (ext->file_descriptor_table == nullptr) {
- ext->file_descriptor_table.reset(new std::vector<int>(sg_storage_max_file_descriptors));
- std::iota(ext->file_descriptor_table->rbegin(), ext->file_descriptor_table->rend(), 0); // Fill with ..., 1, 0.
- }
- xbt_assert(not ext->file_descriptor_table->empty(), "Too much files are opened! Some have to be closed.");
- desc_id = ext->file_descriptor_table->back();
- ext->file_descriptor_table->pop_back();
+ // assign a file descriptor id to the newly opened File
+ FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
+ if (ext->file_descriptor_table == nullptr) {
+ ext->file_descriptor_table.reset(new std::vector<int>(sg_storage_max_file_descriptors));
+ std::iota(ext->file_descriptor_table->rbegin(), ext->file_descriptor_table->rend(), 0); // Fill with ..., 1, 0.
+ }
+ xbt_assert(not ext->file_descriptor_table->empty(), "Too much files are opened! Some have to be closed.");
+ desc_id = ext->file_descriptor_table->back();
+ ext->file_descriptor_table->pop_back();
- XBT_DEBUG("\tOpen file '%s'", path_.c_str());
- std::map<std::string, sg_size_t>* content = nullptr;
- if (local_storage_)
- content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ XBT_DEBUG("\tOpen file '%s'", path_.c_str());
+ std::map<std::string, sg_size_t>* content = nullptr;
+ if (local_storage_)
+ content = local_storage_->extension<FileSystemStorageExt>()->get_content();
- if (local_disk_)
- content = local_disk_->extension<FileSystemDiskExt>()->get_content();
+ if (local_disk_)
+ content = local_disk_->extension<FileSystemDiskExt>()->get_content();
- // if file does not exist create an empty file
- if (content) {
- auto sz = content->find(path_);
- if (sz != content->end()) {
- size_ = sz->second;
- } else {
- size_ = 0;
- content->insert({path_, size_});
- XBT_DEBUG("File '%s' was not found, file created.", path_.c_str());
+ // if file does not exist create an empty file
+ if (content) {
+ auto sz = content->find(path_);
+ if (sz != content->end()) {
+ size_ = sz->second;
+ } else {
+ size_ = 0;
+ content->insert({path_, size_});
+ XBT_DEBUG("File '%s' was not found, file created.", path_.c_str());
+ }
}
- }
+ });
}
File::~File()
{
- Host::current()->extension<simgrid::s4u::FileDescriptorHostExt>()->file_descriptor_table->push_back(desc_id);
+ std::vector<int>* desc_table =
+ Host::current()->extension<simgrid::s4u::FileDescriptorHostExt>()->file_descriptor_table.get();
+ kernel::actor::simcall([this, desc_table] { desc_table->push_back(this->desc_id); });
}
-void File::dump()
+void File::dump() const
{
if (local_storage_)
XBT_INFO("File Descriptor information:\n"
if (host && host->get_name() != Host::current()->get_name() && read_size > 0) {
/* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), read_size);
- host->send_to(Host::current(), read_size);
+ host->sendto(Host::current(), read_size);
}
return read_size;
if (host && host->get_name() != Host::current()->get_name()) {
/* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
- Host::current()->send_to(host, size);
+ Host::current()->sendto(host, size);
}
XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_disk_->get_cname(), size, size_,
sg_disk_get_size_used(local_disk_), sg_disk_get_size(local_disk_));
if (current_position_ > size_)
size_ = current_position_;
}
- std::map<std::string, sg_size_t>* content = local_disk_->extension<FileSystemDiskExt>()->get_content();
+ kernel::actor::simcall([this] {
+ std::map<std::string, sg_size_t>* content = local_disk_->extension<FileSystemDiskExt>()->get_content();
- content->erase(path_);
- content->insert({path_, size_});
+ content->erase(path_);
+ content->insert({path_, size_});
+ });
return write_size;
}
if (host && host->get_name() != Host::current()->get_name()) {
/* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
- Host::current()->send_to(host, size);
+ Host::current()->sendto(host, size);
}
XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_storage_->get_cname(), size, size_,
if (current_position_ > size_)
size_ = current_position_;
}
- std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ kernel::actor::simcall([this] {
+ std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
- content->erase(path_);
- content->insert({path_, size_});
+ content->erase(path_);
+ content->insert({path_, size_});
+ });
return write_size;
}
return 0;
}
-sg_size_t File::size()
+sg_size_t File::size() const
{
return size_;
}
}
}
-sg_size_t File::tell()
+sg_size_t File::tell() const
{
return current_position_;
}
-void File::move(const std::string& fullpath)
+void File::move(const std::string& fullpath) const
{
/* Check if the new full path is on the same mount point */
if (fullpath.compare(0, mount_point_.length(), mount_point_) == 0) {
}
}
-int File::unlink()
+int File::unlink() const
{
/* Check if the file is on local storage */
std::map<std::string, sg_size_t>* content = nullptr;
size_t longest_prefix_length = 0;
if (local_storage_) {
/* Find the host that owns the storage where the file has to be copied */
- Storage* storage_dest = nullptr;
+ const Storage* storage_dest = nullptr;
for (auto const& elm : host->get_mounted_storages()) {
std::string mount_point = std::string(fullpath).substr(0, elm.first.size());
if (src_host) {
XBT_DEBUG("Initiate data transfer of %llu bytes between %s and %s.", read_size, src_host->get_cname(),
dst_host->get_cname());
- src_host->send_to(dst_host, read_size);
+ src_host->sendto(dst_host, read_size);
}
/* Create file on remote host, write it and close it */
return res;
}
-FileSystemDiskExt::FileSystemDiskExt(simgrid::s4u::Disk* ptr)
+FileSystemDiskExt::FileSystemDiskExt(const Disk* ptr)
{
const char* size_str = ptr->get_property("size");
+ std::string dummyfile;
if (size_str)
- size_ = surf_parse_get_size(size_str, "disk size", ptr->get_name());
+ size_ = surf_parse_get_size(dummyfile, -1, size_str, "disk size", ptr->get_name());
const char* current_mount_str = ptr->get_property("mount");
if (current_mount_str)
content_.reset(parse_content(content_str));
}
-FileSystemStorageExt::FileSystemStorageExt(simgrid::s4u::Storage* ptr) : size_(ptr->get_impl()->size_)
+FileSystemStorageExt::FileSystemStorageExt(const Storage* ptr) : size_(ptr->get_impl()->size_)
{
content_.reset(parse_content(ptr->get_impl()->content_name_));
}
std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
std::ifstream* fs = surf_ifsopen(filename);
+ xbt_assert(not fs->fail(), "Cannot open file '%s' (path=%s)", filename.c_str(),
+ (boost::join(surf_path, ":")).c_str());
std::string line;
std::vector<std::string> tokens;
std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
std::ifstream* fs = surf_ifsopen(filename);
+ xbt_assert(not fs->fail(), "Cannot open file '%s' (path=%s)", filename.c_str(),
+ (boost::join(surf_path, ":")).c_str());
std::string line;
std::vector<std::string> tokens;
delete fs;
return parse_content;
}
+
+void FileSystemStorageExt::decr_used_size(sg_size_t size)
+{
+ simgrid::kernel::actor::simcall([this, size] { used_size_ -= size; });
+}
+
+void FileSystemStorageExt::incr_used_size(sg_size_t size)
+{
+ simgrid::kernel::actor::simcall([this, size] { used_size_ += size; });
+}
+
+void FileSystemDiskExt::decr_used_size(sg_size_t size)
+{
+ simgrid::kernel::actor::simcall([this, size] { used_size_ -= size; });
+}
+
+void FileSystemDiskExt::incr_used_size(sg_size_t size)
+{
+ simgrid::kernel::actor::simcall([this, size] { used_size_ += size; });
+}
}
}
return fd->write(size);
}
-void sg_file_close(sg_file_t fd)
+void sg_file_close(const_sg_file_t fd)
{
delete fd;
}
/** Retrieves the path to the file
* @ingroup plugin_filesystem
*/
-const char* sg_file_get_name(sg_file_t fd)
+const char* sg_file_get_name(const_sg_file_t fd)
{
xbt_assert((fd != nullptr), "Invalid file descriptor");
return fd->get_path();
/** Retrieves the size of the file
* @ingroup plugin_filesystem
*/
-sg_size_t sg_file_get_size(sg_file_t fd)
+sg_size_t sg_file_get_size(const_sg_file_t fd)
{
return fd->size();
}
-void sg_file_dump(sg_file_t fd)
+void sg_file_dump(const_sg_file_t fd)
{
fd->dump();
}
/** Retrieves the user data associated with the file
* @ingroup plugin_filesystem
*/
-void* sg_file_get_data(sg_file_t fd)
+void* sg_file_get_data(const_sg_file_t fd)
{
return fd->get_data();
}
fd->seek(offset, origin);
}
-sg_size_t sg_file_tell(sg_file_t fd)
+sg_size_t sg_file_tell(const_sg_file_t fd)
{
return fd->tell();
}
-void sg_file_move(sg_file_t fd, const char* fullpath)
+void sg_file_move(const_sg_file_t fd, const char* fullpath)
{
fd->move(fullpath);
}
return file->remote_move(host, fullpath);
}
-sg_size_t sg_disk_get_size_free(sg_disk_t d)
+sg_size_t sg_disk_get_size_free(const_sg_disk_t d)
{
return d->extension<FileSystemDiskExt>()->get_size() - d->extension<FileSystemDiskExt>()->get_used_size();
}
-sg_size_t sg_disk_get_size_used(sg_disk_t d)
+sg_size_t sg_disk_get_size_used(const_sg_disk_t d)
{
return d->extension<FileSystemDiskExt>()->get_used_size();
}
-sg_size_t sg_disk_get_size(sg_disk_t d)
+sg_size_t sg_disk_get_size(const_sg_disk_t d)
{
return d->extension<FileSystemDiskExt>()->get_size();
}
-const char* sg_disk_get_mount_point(sg_disk_t d)
+const char* sg_disk_get_mount_point(const_sg_disk_t d)
{
return d->extension<FileSystemDiskExt>()->get_mount_point();
}
-sg_size_t sg_storage_get_size_free(sg_storage_t st)
+sg_size_t sg_storage_get_size_free(const_sg_storage_t st)
{
return st->extension<FileSystemStorageExt>()->get_size() - st->extension<FileSystemStorageExt>()->get_used_size();
}
-sg_size_t sg_storage_get_size_used(sg_storage_t st)
+sg_size_t sg_storage_get_size_used(const_sg_storage_t st)
{
return st->extension<FileSystemStorageExt>()->get_used_size();
}
-sg_size_t sg_storage_get_size(sg_storage_t st)
+sg_size_t sg_storage_get_size(const_sg_storage_t st)
{
return st->extension<FileSystemStorageExt>()->get_size();
}
-xbt_dict_t sg_storage_get_content(sg_storage_t storage)
+xbt_dict_t sg_storage_get_content(const_sg_storage_t storage)
{
const std::map<std::string, sg_size_t>* content =
storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
