-/* Copyright (c) 2015-2020. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2015-2021. 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 <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/split.hpp>
#include <fstream>
+#include <memory>
#include <numeric>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_file, s4u, "S4U files");
}
// assign a file descriptor id to the newly opened File
- FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
+ auto* 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));
+ ext->file_descriptor_table = std::make_unique<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.");
ext->file_descriptor_table->pop_back();
XBT_DEBUG("\tOpen file '%s'", path_.c_str());
- std::map<std::string, sg_size_t>* content = nullptr;
+ std::map<std::string, sg_size_t, std::less<>>* content = nullptr;
if (local_storage_)
content = local_storage_->extension<FileSystemStorageExt>()->get_content();
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 (size_ == 0) /* Nothing to read, return */
return 0;
- sg_size_t read_size = 0;
Host* host = nullptr;
+ // if the current position is close to the end of the file, we may not be able to read the requested size
+ sg_size_t to_read = std::min(size, size_ - current_position_);
+ sg_size_t read_size = 0;
+
if (local_storage_) {
/* Find the host where the file is physically located and read it */
host = local_storage_->get_host();
XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
- // if the current position is close to the end of the file, we may not be able to read the requested size
- read_size = local_storage_->read(std::min(size, size_ - current_position_));
- current_position_ += read_size;
+ read_size = local_storage_->read(to_read);
}
if (local_disk_) {
/* Find the host where the file is physically located and read it */
host = local_disk_->get_host();
XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
- // if the current position is close to the end of the file, we may not be able to read the requested size
- read_size = local_disk_->read(std::min(size, size_ - current_position_));
- current_position_ += read_size;
+ read_size = local_disk_->read(to_read);
}
+ current_position_ += read_size;
+
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);
size_ = current_position_;
}
kernel::actor::simcall([this] {
- std::map<std::string, sg_size_t>* content = local_disk_->extension<FileSystemDiskExt>()->get_content();
+ std::map<std::string, sg_size_t, std::less<>>* content = local_disk_->extension<FileSystemDiskExt>()->get_content();
content->erase(path_);
content->insert({path_, size_});
size_ = current_position_;
}
kernel::actor::simcall([this] {
- std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ std::map<std::string, sg_size_t, std::less<>>* content =
+ local_storage_->extension<FileSystemStorageExt>()->get_content();
content->erase(path_);
content->insert({path_, 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) {
- std::map<std::string, sg_size_t>* content = nullptr;
+ std::map<std::string, sg_size_t, std::less<>>* content = nullptr;
if (local_storage_)
content = local_storage_->extension<FileSystemStorageExt>()->get_content();
if (local_disk_)
}
}
-int File::unlink()
+int File::unlink() const
{
/* Check if the file is on local storage */
- std::map<std::string, sg_size_t>* content = nullptr;
+ std::map<std::string, sg_size_t, std::less<>>* content = nullptr;
const char* name = "";
if (local_storage_) {
content = local_storage_->extension<FileSystemStorageExt>()->get_content();
}
}
-int File::remote_copy(sg_host_t host, const char* fullpath)
+int File::remote_copy(sg_host_t host, const std::string& fullpath)
{
/* Find the host where the file is physically located and read it */
- Host* src_host = nullptr;
- if (local_storage_) {
- src_host = local_storage_->get_host();
- XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
- }
-
- if (local_disk_) {
- src_host = local_disk_->get_host();
- XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
- }
-
- seek(0, SEEK_SET);
- // if the current position is close to the end of the file, we may not be able to read the requested size
+ Host* src_host = nullptr;
sg_size_t read_size = 0;
- if (local_storage_)
- read_size = local_storage_->read(size_);
- if (local_disk_)
- read_size = local_disk_->read(size_);
-
- current_position_ += read_size;
Host* dst_host = host;
size_t longest_prefix_length = 0;
+
+ seek(0, SEEK_SET);
+
if (local_storage_) {
+ src_host = local_storage_->get_host();
+ XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
+ read_size = local_storage_->read(size_);
+ current_position_ += read_size;
+
/* Find the host that owns the storage where the file has to be copied */
const Storage* storage_dest = nullptr;
/* Mount point found, retrieve the host the storage is attached to */
dst_host = storage_dest->get_host();
} else {
- XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
+ XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath.c_str(), host->get_cname());
return -1;
}
}
if (local_disk_) {
+ src_host = local_disk_->get_host();
+ XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
+ read_size = local_disk_->read(size_);
+ current_position_ += read_size;
+
const Disk* dst_disk = nullptr;
for (auto const& disk : host->get_disks()) {
}
if (dst_disk == nullptr) {
- XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
+ XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath.c_str(), host->get_cname());
return -1;
}
}
}
/* Create file on remote host, write it and close it */
- File* fd = new File(fullpath, dst_host, nullptr);
+ File fd(fullpath, dst_host, nullptr);
if (local_storage_) {
- sg_size_t write_size = fd->local_storage_->write(read_size);
- fd->local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
- (*(fd->local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
+ sg_size_t write_size = fd.local_storage_->write(read_size);
+ fd.local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
+ (*(fd.local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
}
if (local_disk_)
- fd->write(read_size);
- delete fd;
+ fd.write(read_size);
return 0;
}
-int File::remote_move(sg_host_t host, const char* fullpath)
+int File::remote_move(sg_host_t host, const std::string& fullpath)
{
int res = remote_copy(host, fullpath);
unlink();
content_.reset(parse_content(ptr->get_impl()->content_name_));
}
-std::map<std::string, sg_size_t>* FileSystemDiskExt::parse_content(const std::string& filename)
+std::map<std::string, sg_size_t, std::less<>>* FileSystemDiskExt::parse_content(const std::string& filename)
{
if (filename.empty())
return nullptr;
- std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
+ auto* parse_content = new std::map<std::string, sg_size_t, std::less<>>();
- std::ifstream* fs = surf_ifsopen(filename);
+ auto fs = std::unique_ptr<std::ifstream>(surf_ifsopen(filename));
xbt_assert(not fs->fail(), "Cannot open file '%s' (path=%s)", filename.c_str(),
(boost::join(surf_path, ":")).c_str());
parse_content->insert({tokens.front(), size});
}
} while (not fs->eof());
- delete fs;
return parse_content;
}
-std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(const std::string& filename)
+std::map<std::string, sg_size_t, std::less<>>* FileSystemStorageExt::parse_content(const std::string& filename)
{
if (filename.empty())
return nullptr;
- std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
+ auto* parse_content = new std::map<std::string, sg_size_t, std::less<>>();
- std::ifstream* fs = surf_ifsopen(filename);
+ auto fs = std::unique_ptr<std::ifstream>(surf_ifsopen(filename));
xbt_assert(not fs->fail(), "Cannot open file '%s' (path=%s)", filename.c_str(),
(boost::join(surf_path, ":")).c_str());
parse_content->insert({tokens.front(), size});
}
} while (not fs->eof());
- delete fs;
return parse_content;
}
simgrid::s4u::Host* remote_host = simgrid::s4u::Host::by_name_or_null(tokens[2]);
xbt_assert(remote_host, "You're trying to access a host that does not exist. Please check your platform file");
- simgrid::s4u::Disk* disk = nullptr;
+ const simgrid::s4u::Disk* disk = nullptr;
for (auto const& d : remote_host->get_disks())
if (d->get_name() == tokens[1]) {
disk = d;
/** 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();
}
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);
}
xbt_dict_t sg_storage_get_content(const_sg_storage_t storage)
{
- const std::map<std::string, sg_size_t>* content =
+ const std::map<std::string, sg_size_t, std::less<>>* content =
storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
// Note: ::operator delete is ok here (no destructor called) since the dict elements are of POD type sg_size_t.
xbt_dict_t content_as_dict = xbt_dict_new_homogeneous(::operator delete);
for (auto const& entry : *content) {
- sg_size_t* psize = new sg_size_t;
- *psize = entry.second;
+ auto* psize = new sg_size_t(entry.second);
xbt_dict_set(content_as_dict, entry.first.c_str(), psize);
}
return content_as_dict;