File simple_memory.h

File List > mem > simple_memory.h

Go to the documentation of this file

#pragma once

#include <fmt/core.h>
#include <sim/queue.h>
#include <simtix/mem.h>

#include <cstddef>
#include <cstdint>
#include <string>
#include <utility>

namespace simtix {

namespace mem {

// Class: mem::SimpleMemory::Impl
//   A simple memory implementation with fixed latency.
class SimpleMemory::Impl {
 public:
  struct Request {
    Request(const Payload &payload, bool is_write, OnResp on_resp)
        : payload(payload),
          is_write(is_write),
          resp_status(RespStatus::kGenericError),
          on_resp(std::move(on_resp)) {}

    Request(Request &&other)
        : payload(other.payload),
          is_write(other.is_write),
          resp_status(other.resp_status),
          on_resp(std::move(other.on_resp)) {}

    Payload payload;
    bool is_write;
    RespStatus resp_status;
    OnResp on_resp;
  };

  // Class: mem::SimpleMemory::Impl

  explicit Impl(const std::string &name, const Param &param = kDefaultParam);
  ~Impl();

  Impl(const Impl &s) = delete;
  Impl operator=(const Impl &s) = delete;
  uint8_t &operator[](const uint64_t addr) { return mem_[addr]; }

 protected:
  // Group: Protected Functions

  bool AcceptRequest(const Payload &payload, OnResp on_resp, bool is_write);
  void HandleRequest();
  void HandleDelay();
  void HandleResponse();

  RespStatus HandleReadWrite(const Payload &payload, bool is_write);

  void Tick();

  const std::string name_;
  const size_t size_;       // memory size in bytes
  const uint32_t latency_;  // latency in cycles
  uint8_t *mem_;

  sim::DelayQueue<Request> delay_queue_;
  sim::SizedQueue<Request> req_queue_;
  sim::SizedQueue<Request> resp_queue_;

  friend class SimpleMemory;
};

}  // namespace mem

}  // namespace simtix