X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5d00e5f256a27ccad82ab92aeea7943d2678e85b..7d28d93b90eedd2a49da8b9b990296669e46d05c:/src/plugins/file_system/s4u_FileSystem.cpp

diff --git a/src/plugins/file_system/s4u_FileSystem.cpp b/src/plugins/file_system/s4u_FileSystem.cpp
index fce578d9f1..25c6cafd96 100644
--- a/src/plugins/file_system/s4u_FileSystem.cpp
+++ b/src/plugins/file_system/s4u_FileSystem.cpp
@@ -1,4 +1,4 @@
-/* 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. */
@@ -9,18 +9,29 @@
 #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>
 #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");
 int sg_storage_max_file_descriptors = 1024;
 
+/** @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;
@@ -51,7 +62,7 @@ Storage* File::find_local_storage_on(Host* host)
   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;
@@ -84,52 +95,56 @@ File::File(const std::string& fullpath, void* userdata) : File(fullpath, Host::c
 
 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
+    auto* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
+    if (ext->file_descriptor_table == nullptr) {
+      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.");
+    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"
@@ -179,13 +194,14 @@ sg_size_t File::read(sg_size_t 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);
-    host->send_to(Host::current(), read_size);
+    host->sendto(Host::current(), read_size);
   }
 
   return read_size;
 }
 
 /** @brief Write into a file (local or remote)
+ * @ingroup plugin_filesystem
  *
  * @param size of the file to write
  * @return the number of bytes successfully write or -1 if an error occurred
@@ -199,7 +215,7 @@ sg_size_t File::write_on_disk(sg_size_t size, bool write_inside)
   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_));
@@ -219,10 +235,12 @@ sg_size_t File::write_on_disk(sg_size_t size, bool write_inside)
     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;
 }
@@ -236,7 +254,7 @@ sg_size_t File::write_on_storage(sg_size_t size, bool write_inside)
   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_,
@@ -257,10 +275,12 @@ sg_size_t File::write_on_storage(sg_size_t size, bool write_inside)
     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;
 }
@@ -278,7 +298,7 @@ sg_size_t File::write(sg_size_t size, bool write_inside)
   return 0;
 }
 
-sg_size_t File::size()
+sg_size_t File::size() const
 {
   return size_;
 }
@@ -305,12 +325,12 @@ void File::seek(sg_offset_t offset, int origin)
   }
 }
 
-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) {
@@ -336,7 +356,7 @@ void File::move(const std::string& fullpath)
   }
 }
 
-int File::unlink()
+int File::unlink() const
 {
   /* Check if the file is on local storage */
   std::map<std::string, sg_size_t>* content = nullptr;
@@ -369,7 +389,7 @@ int File::unlink()
   }
 }
 
-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;
@@ -397,7 +417,7 @@ int File::remote_copy(sg_host_t host, const char* fullpath)
   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());
@@ -412,13 +432,13 @@ int File::remote_copy(sg_host_t host, const char* fullpath)
       /* 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_) {
-    Disk* dst_disk               = nullptr;
+    const Disk* dst_disk = nullptr;
 
     for (auto const& disk : host->get_disks()) {
       std::string current_mount = disk->extension<FileSystemDiskExt>()->get_mount_point();
@@ -431,7 +451,7 @@ int File::remote_copy(sg_host_t host, const char* fullpath)
     }
 
     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;
     }
   }
@@ -439,34 +459,34 @@ int File::remote_copy(sg_host_t host, const char* fullpath)
   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 */
-  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();
   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)
@@ -479,7 +499,7 @@ FileSystemDiskExt::FileSystemDiskExt(simgrid::s4u::Disk* ptr)
     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_));
 }
@@ -489,9 +509,11 @@ std::map<std::string, sg_size_t>* FileSystemDiskExt::parse_content(const std::st
   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::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;
@@ -516,9 +538,11 @@ std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(const std:
   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::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;
@@ -537,6 +561,26 @@ std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(const std:
   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; });
+}
 }
 }
 
@@ -569,7 +613,7 @@ static void on_platform_created()
       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;
@@ -604,6 +648,13 @@ static void on_simulation_end()
 }
 
 /* **************************** Public interface *************************** */
+/** @brief Initialize the file system plugin.
+    @ingroup plugin_filesystem
+
+    @beginrst
+    See the examples in :ref:`s4u_ex_disk_io`.
+    @endrst
+ */
 void sg_storage_file_system_init()
 {
   sg_storage_max_file_descriptors = 1024;
@@ -643,40 +694,52 @@ sg_size_t sg_file_write(sg_file_t fd, sg_size_t size)
   return fd->write(size);
 }
 
-void sg_file_close(sg_file_t fd)
+void sg_file_close(const_sg_file_t fd)
 {
   delete fd;
 }
 
-const char* sg_file_get_name(sg_file_t fd)
+/** Retrieves the path to the file
+ * @ingroup plugin_filesystem
+ */
+const char* sg_file_get_name(const_sg_file_t fd)
 {
   xbt_assert((fd != nullptr), "Invalid file descriptor");
   return fd->get_path();
 }
 
-sg_size_t sg_file_get_size(sg_file_t fd)
+/** Retrieves the size of the file
+ * @ingroup plugin_filesystem
+ */
+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();
 }
 
-void* sg_file_get_data(sg_file_t fd)
+/** Retrieves the user data associated with the file
+ * @ingroup plugin_filesystem
+ */
+void* sg_file_get_data(const_sg_file_t fd)
 {
   return fd->get_data();
 }
 
+/** Changes the user data associated with the file
+ * @ingroup plugin_filesystem
+ */
 void sg_file_set_data(sg_file_t fd, void* data)
 {
   fd->set_data(data);
 }
 
 /**
- * @brief Set the file position indicator in the sg_file_t by adding offset bytes
- * to the position specified by origin (either SEEK_SET, SEEK_CUR, or SEEK_END).
+ * @brief Set the file position indicator in the sg_file_t by adding offset bytes to the position specified by origin (either SEEK_SET, SEEK_CUR, or SEEK_END).
+ * @ingroup plugin_filesystem
  *
  * @param fd : file object that identifies the stream
  * @param offset : number of bytes to offset from origin
@@ -689,12 +752,12 @@ void sg_file_seek(sg_file_t fd, sg_offset_t offset, int origin)
   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);
 }
@@ -707,6 +770,8 @@ void sg_file_unlink(sg_file_t fd)
 
 /**
  * @brief Copy a file to another location on a remote host.
+ * @ingroup plugin_filesystem
+ *
  * @param file : the file to move
  * @param host : the remote host where the file has to be copied
  * @param fullpath : the complete path destination on the remote host
@@ -719,6 +784,8 @@ int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath)
 
 /**
  * @brief Move a file to another location on a remote host.
+ * @ingroup plugin_filesystem
+ *
  * @param file : the file to move
  * @param host : the remote host where the file has to be moved
  * @param fullpath : the complete path destination on the remote host
@@ -729,50 +796,50 @@ int sg_file_rmove(sg_file_t file, sg_host_t host, const char* 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)
 {
-  std::map<std::string, sg_size_t>* content = storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
+  const std::map<std::string, sg_size_t>* 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;