Filetree, datasizes, and aging methods implemenation

janjurca · Jan 24, 2024 · 917265a · 917265a
1 parent ee2baad
commit 917265a
Show file tree

Hide file tree

Showing 12 changed files with 257 additions and 96 deletions.
diff --git a/include/filestorm/actions/actions.h b/include/filestorm/actions/actions.h
@@ -21,9 +21,7 @@ class FileActionAttributes {
   const std::chrono::seconds m_time_limit;
 
 public:
-  FileActionAttributes(bool time_based, DataSize<DataUnit::B> block_size,
-                       DataSize<DataUnit::KB> file_size, std::string file_path,
-                       std::chrono::seconds time_limit);
+  FileActionAttributes(bool time_based, DataSize<DataUnit::B> block_size, DataSize<DataUnit::KB> file_size, std::string file_path, std::chrono::seconds time_limit);
 
   DataSize<DataUnit::B> get_block_size() const;
   DataSize<DataUnit::KB> get_file_size() const;
@@ -53,6 +51,15 @@ class VirtualMeasuredAction {
   std::chrono::nanoseconds getLastDuration();
 };
 
+class MeasuredCBAction : public VirtualMeasuredAction {
+public:
+  std::function<void()> m_cb;
+
+  MeasuredCBAction(std::function<void()> cb) : m_cb(cb) {}
+
+  void work() override { m_cb(); }
+};
+
 class VirtualMonitoredAction {
 protected:
   std::chrono::milliseconds m_interval;
@@ -65,8 +72,7 @@ class VirtualMonitoredAction {
   std::function<void(VirtualMonitoredAction*)> m_on_log;
 
 public:
-  VirtualMonitoredAction(std::chrono::milliseconds monitoring_interval,
-                         std::function<void(VirtualMonitoredAction*)> on_log);
+  VirtualMonitoredAction(std::chrono::milliseconds monitoring_interval, std::function<void(VirtualMonitoredAction*)> on_log);
 
   ~VirtualMonitoredAction();
 
@@ -81,7 +87,6 @@ class VirtualMonitoredAction {
   void addMonitoredData(std::string name, float value);
 
   std::chrono::milliseconds get_interval();
-  std::map<std::string, std::vector<std::tuple<std::chrono::nanoseconds, float>>>
-  get_monitored_data();
+  std::map<std::string, std::vector<std::tuple<std::chrono::nanoseconds, float>>> get_monitored_data();
   std::chrono::nanoseconds get_monitor_started_at();
 };
diff --git a/include/filestorm/actions/rw_actions.h b/include/filestorm/actions/rw_actions.h
@@ -28,45 +28,41 @@
 #include <vector>
 // ABOUT DIRECT IO https://github.com/facebook/rocksdb/wiki/Direct-IO
 
-class ReadAction : public VirtualMonitoredAction, public FileActionAttributes {
+class ReadMonitoredAction : public VirtualMonitoredAction, public FileActionAttributes {
 protected:
   u_int64_t m_read_bytes = 0;
 
   inline off_t get_offset();
 
 public:
-  ReadAction(std::chrono::milliseconds monitoring_interval,
-             std::function<void(VirtualMonitoredAction*)> on_log,
-             FileActionAttributes file_attributes);
+  ReadMonitoredAction(std::chrono::milliseconds monitoring_interval, std::function<void(VirtualMonitoredAction*)> on_log, FileActionAttributes file_attributes);
 
   void work() override;
   void log_values() override;
 };
-class RandomReadAction : public ReadAction {
+class RandomReadMonitoredAction : public ReadMonitoredAction {
 private:
   std::vector<off_t> m_offsets;
 
   inline off_t get_offset();
 };
 
-class WriteAction : public VirtualMonitoredAction, public FileActionAttributes {
+class WriteMonitoredAction : public VirtualMonitoredAction, public FileActionAttributes {
 protected:
   u_int64_t m_written_bytes = 0;
 
   inline off_t get_offset();
   inline void generate_random_chunk(char* chunk, size_t size);
 
 public:
-  WriteAction(std::chrono::milliseconds monitoring_interval,
-              std::function<void(VirtualMonitoredAction*)> on_log,
-              FileActionAttributes file_attributes);
+  WriteMonitoredAction(std::chrono::milliseconds monitoring_interval, std::function<void(VirtualMonitoredAction*)> on_log, FileActionAttributes file_attributes);
 
   void work() override;
 
   void log_values() override;
 };
 
-class RandomWriteAction : public WriteAction {
+class RandomWriteMonitoredAction : public WriteMonitoredAction {
 private:
   std::vector<off_t> m_offsets;
 

diff --git a/include/filestorm/data_sizes.h b/include/filestorm/data_sizes.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <filestorm/utils.h>
 #include <fmt/core.h>  // or #include <fmt/format.h> based on your fmt version
 
 #include <cstdint>
@@ -19,14 +20,11 @@ template <DataUnit T> class DataSize {
   bool m_allow_rounding;
 
 public:
-  DataSize(uint64_t value, bool allow_rounding = false)
-      : m_value(value), m_allow_rounding(allow_rounding) {}
+  DataSize() : m_value(0), m_allow_rounding(false) {}
+  DataSize(uint64_t value, bool allow_rounding = false) : m_value(value), m_allow_rounding(allow_rounding) {}
 
   // Converting constructor
-  template <DataUnit U> DataSize(const DataSize<U> &other, bool allow_rounding = false)
-      : m_allow_rounding(allow_rounding || other.allow_rounding()) {
-    *this = other.template convert<T>();
-  }
+  template <DataUnit U> DataSize(const DataSize<U> &other, bool allow_rounding = false) : m_allow_rounding(allow_rounding || other.allow_rounding()) { *this = other.template convert<T>(); }
 
   uint64_t get_value() const { return m_value; }
 
@@ -84,42 +82,61 @@ template <DataUnit T> class DataSize {
     m_value %= converted_rhs;
     return *this;
   }
-  template <DataUnit U> bool operator==(const DataSize<U> &rhs) const {
-    return m_value == rhs.template convert<T>().get_value();
-  }
+  template <DataUnit U> bool operator==(const DataSize<U> &rhs) const { return m_value == rhs.template convert<T>().get_value(); }
 
-  template <DataUnit U> bool operator!=(const DataSize<U> &rhs) const {
-    return m_value != rhs.template convert<T>().get_value();
-  }
+  template <DataUnit U> bool operator!=(const DataSize<U> &rhs) const { return m_value != rhs.template convert<T>().get_value(); }
 
-  template <DataUnit U> bool operator<(const DataSize<U> &rhs) const {
-    return m_value < rhs.template convert<T>().get_value();
-  }
+  template <DataUnit U> bool operator<(const DataSize<U> &rhs) const { return m_value < rhs.template convert<T>().get_value(); }
 
-  template <DataUnit U> bool operator>(const DataSize<U> &rhs) const {
-    return m_value > rhs.template convert<T>().get_value();
-  }
+  template <DataUnit U> bool operator>(const DataSize<U> &rhs) const { return m_value > rhs.template convert<T>().get_value(); }
 
-  template <DataUnit U> bool operator<=(const DataSize<U> &rhs) const {
-    return m_value <= rhs.template convert<T>().get_value();
-  }
+  template <DataUnit U> bool operator<=(const DataSize<U> &rhs) const { return m_value <= rhs.template convert<T>().get_value(); }
 
-  template <DataUnit U> bool operator>=(const DataSize<U> &rhs) const {
-    return m_value >= rhs.template convert<T>().get_value();
-  }
+  template <DataUnit U> bool operator>=(const DataSize<U> &rhs) const { return m_value >= rhs.template convert<T>().get_value(); }
 
   template <DataUnit NewDataUnit> DataSize<NewDataUnit> convert() const {
-    if (static_cast<uint64_t>(T) < static_cast<uint64_t>(NewDataUnit)
-        && (m_value * static_cast<uint64_t>(T)) % static_cast<uint64_t>(NewDataUnit) != 0
-        && !m_allow_rounding) {
+    if (static_cast<uint64_t>(T) < static_cast<uint64_t>(NewDataUnit) && (m_value * static_cast<uint64_t>(T)) % static_cast<uint64_t>(NewDataUnit) != 0 && !m_allow_rounding) {
       throw std::runtime_error("Cannot convert to a bigger unit with a remainder");
     }
 
-    return DataSize<NewDataUnit>(
-        m_value * static_cast<uint64_t>(T) / static_cast<uint64_t>(NewDataUnit), m_allow_rounding);
+    return DataSize<NewDataUnit>(m_value * static_cast<uint64_t>(T) / static_cast<uint64_t>(NewDataUnit), m_allow_rounding);
   }
 
   bool allow_rounding() const { return m_allow_rounding; }
+
+  static DataSize<T> fromString(const std::string &str) {
+    std::string value_str;
+    std::string unit_str;
+    for (auto &c : str) {
+      if (std::isdigit(c)) {
+        value_str += c;
+      } else {
+        unit_str += c;
+      }
+    }
+    if (value_str.empty() || unit_str.empty()) {
+      throw std::runtime_error(fmt::format("Invalid data size string: {}", str));
+    }
+    unit_str = toUpper(unit_str);
+    uint64_t value = std::stoull(value_str);
+    DataUnit unit;
+    if (unit_str == "B") {
+      unit = DataUnit::B;
+    } else if (unit_str == "KB" || unit_str == "K") {
+      unit = DataUnit::KB;
+    } else if (unit_str == "MB" || unit_str == "M") {
+      unit = DataUnit::MB;
+    } else if (unit_str == "GB" || unit_str == "G") {
+      unit = DataUnit::GB;
+    } else if (unit_str == "TB" || unit_str == "T") {
+      unit = DataUnit::TB;
+    } else if (unit_str == "PB" || unit_str == "P") {
+      unit = DataUnit::PB;
+    } else {
+      return DataSize<T>();
+    }
+    return DataSize<T>(value, false).template convert<T>();
+  }
 };
 
 template <DataUnit T> struct fmt::formatter<DataSize<T>> {
@@ -129,8 +146,7 @@ template <DataUnit T> struct fmt::formatter<DataSize<T>> {
   }
 
   // This is where you define how to format DataSize
-  template <typename FormatContext> auto format(const DataSize<T> &size, FormatContext &ctx)
-      -> decltype(ctx.out()) {
+  template <typename FormatContext> auto format(const DataSize<T> &size, FormatContext &ctx) -> decltype(ctx.out()) {
     std::string unit;
     switch (T) {
       case DataUnit::B:

diff --git a/include/filestorm/filetree.h b/include/filestorm/filetree.h
@@ -66,6 +66,9 @@ class FileTree {
   std::string newDirectoryPath();
   std::string newFilePath();
 
+  Node* randomFile();
+  Node* randomDirectory();
+
 private:
   void printRec(const Node* node, int depth) const;
 };

diff --git a/include/filestorm/result.h b/include/filestorm/result.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <filestorm/data_sizes.h>
+#include <filestorm/filetree.h>
+
+class Result {
+public:
+  enum Operation { WRITE, READ, DELETE_FILE, CREATE_FILE, CREATE_DIR };
+
+private:
+  int _iteration;
+  Operation _operation;
+  std::string _path;
+  DataSize<DataUnit::B> _size;
+  std::chrono::nanoseconds _duration;
+
+public:
+  Result(int iteration, Operation operation, std::string path, DataSize<DataUnit::B> size, std::chrono::nanoseconds duration)
+      : _iteration(iteration), _operation(operation), _path(path), _size(size), _duration(duration) {}
+
+  int getIteration() const { return _iteration; }
+  Operation getOperation() const { return _operation; }
+  std::string getPath() const { return _path; }
+  DataSize<DataUnit::B> getSize() const { return _size; }
+  std::chrono::nanoseconds getDuration() const { return _duration; }
+};
diff --git a/include/filestorm/scenarios/scenario.h b/include/filestorm/scenarios/scenario.h
@@ -97,4 +97,6 @@ class AgingScenario : public Scenario {
   void run() override;
 
   double CAF(double x) { return sqrt(1 - (x * x)); }
+  DataSize<DataUnit::B> get_file_size();
+  DataSize<DataUnit::B> get_file_size(uint64_t min, uint64_t max);
 };
diff --git a/include/filestorm/utils.h b/include/filestorm/utils.h
@@ -5,4 +5,7 @@
 
 std::vector<std::string> split(const std::string& str, char delimiter);
 std::string strip(const std::string& str);
-std::string strip(const std::string& str, const char stripChar = ' ');
+std::string strip(const std::string& str, const char stripChar = ' ');
+
+std::string toLower(const std::string& str);
+std::string toUpper(const std::string& str);
diff --git a/include/filestorm/utils/fs.h b/include/filestorm/utils/fs.h
@@ -6,4 +6,5 @@
 
 namespace fs_utils {
   std::filesystem::space_info get_fs_status(const std::filesystem::path& path) { return std::filesystem::space(path); }
+  uint64_t file_size(const std::filesystem::path& path) { return std::filesystem::file_size(path); }
 }  // namespace fs_utils