disk.hpp

#pragma once
 
#include <coroutine>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include "ravel/clock.hpp"
#include "ravel/rng.hpp"
#include "ravel/scheduler.hpp"
#include "ravel/trace.hpp"
 
namespace ravel {
 
using DiskId = std::size_t;
 
enum class DiskStatus {
  Ok,
  NoSpace,   
  IoError,   
  Crashed,   
  NotFound,  
};
 
const char* to_string(DiskStatus status) noexcept;
 
struct ReadResult {
  DiskStatus status = DiskStatus::Ok;
  std::string data;  
};
 
struct ListResult {
  DiskStatus status = DiskStatus::Ok;
  std::vector<std::string> names;  
};
 
struct DiskFaultSpec {
  std::uint64_t capacity_bytes = 1ULL << 30;
 
  VirtualClock::Tick latency_min = 0;
  VirtualClock::Tick latency_max = 0;
 
  double write_error_probability = 0.0;
 
  double sync_error_probability = 0.0;
};
 
class Disk {
 public:
  static constexpr std::size_t kSectorSize = 512;
 
  Disk(DiskId id, std::string name, DiskFaultSpec fault, Scheduler& scheduler, VirtualRng& rng,
       Trace& trace);
 
  Disk(const Disk&) = delete;
  Disk& operator=(const Disk&) = delete;
 
  const std::string& name() const noexcept { return name_; }
  const DiskFaultSpec& fault() const noexcept { return fault_; }
 
  template <typename Result>
  class Operation {
   public:
    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<>) {
      Scheduler& scheduler = disk_.scheduler_;
      scheduler.call_after(disk_.draw_latency(), [this, task = scheduler.current_task()] {
        result_ = finish_();
        disk_.scheduler_.make_runnable(task);
      });
    }
    Result await_resume() { return std::move(result_); }
 
   private:
    friend class Disk;
    Operation(Disk& disk, std::function<Result()> finish)
        : disk_(disk), finish_(std::move(finish)) {}
 
    Disk& disk_;
    std::function<Result()> finish_;
    Result result_{};
  };
 
  [[nodiscard]] Operation<DiskStatus> write(std::string path, std::uint64_t offset,
                                            std::string data);
 
  [[nodiscard]] Operation<ReadResult> read(std::string path, std::uint64_t offset,
                                           std::uint64_t length);
 
  [[nodiscard]] Operation<DiskStatus> sync(std::string path);
 
  [[nodiscard]] Operation<DiskStatus> rename(std::string from, std::string to);
 
  [[nodiscard]] Operation<DiskStatus> remove(std::string path);
 
  [[nodiscard]] Operation<DiskStatus> sync_dir(std::string dir);
 
  [[nodiscard]] Operation<ListResult> list(std::string dir);
 
  void crash();
 
  std::uint64_t crash_count() const noexcept { return epoch_; }
 
  std::uint64_t file_size(const std::string& path) const;
 
  std::string durable_contents(const std::string& path) const;
 
  bool durable_exists(const std::string& path) const;
 
  std::uint64_t used_bytes() const;
 
 private:
  using InodeId = std::uint64_t;
 
  struct PendingWrite {
    std::uint64_t sequence;  
    std::uint64_t offset;
    std::string data;
  };
 
  struct Inode {
    std::string durable;
    std::vector<PendingWrite> pending;  
    std::uint64_t logical_size = 0;     
  };
 
  enum class NameChange { Create, Rename, Remove };
 
  struct PendingNameChange {
    std::uint64_t sequence;
    NameChange kind;
    std::string path;    
    std::string target;  
    InodeId inode;
  };
 
  using Names = std::map<std::string, InodeId>;
 
  VirtualClock::Tick draw_latency() {
    return rng_.next_between(fault_.latency_min, fault_.latency_max);
  }
  void record(TraceEventKind kind) { trace_.record({scheduler_.now(), id_, kind}); }
 
  DiskStatus finish_write(const std::string& path, std::uint64_t offset, const std::string& data,
                          std::uint64_t epoch);
  ReadResult finish_read(const std::string& path, std::uint64_t offset, std::uint64_t length,
                         std::uint64_t epoch);
  DiskStatus finish_sync(const std::string& path, std::uint64_t horizon, std::uint64_t epoch);
  DiskStatus finish_rename(const std::string& from, const std::string& to, std::uint64_t epoch);
  DiskStatus finish_remove(const std::string& path, std::uint64_t epoch);
  DiskStatus finish_sync_dir(const std::string& dir, std::uint64_t horizon, std::uint64_t epoch);
  ListResult finish_list(const std::string& dir, std::uint64_t epoch);
 
  void make_durable(std::size_t count);
 
  static void apply(std::string& bytes, std::uint64_t offset, const std::string& data);
  static void apply(Names& names, const PendingNameChange& change);
  static void refresh_logical_size(Inode& inode);
  static std::string parent_of(const std::string& path);
 
  DiskId id_;
  std::string name_;
  DiskFaultSpec fault_;
  Scheduler& scheduler_;
  VirtualRng& rng_;
  Trace& trace_;
 
  std::map<InodeId, Inode> inodes_;        
  Names visible_names_;                    
  Names durable_names_;                    
  std::vector<PendingNameChange> pending_names_;
  InodeId next_inode_ = 1;
  std::uint64_t next_sequence_ = 0;        
  std::uint64_t epoch_ = 0;                
};
 
}  // namespace ravel