CachedMemory.hpp

#pragma once
 
#include <list>
#include <cinttypes>
#include <string>
 
#include "sparta/memory/MemoryObject.hpp"
#include "sparta/memory/BlockingMemoryIF.hpp"
#include "sparta/utils/SpartaException.hpp"
 
namespace sparta::memory
{
    class StoreData
    {
    public:
 
        StoreData(uint64_t        write_id,
                  addr_t          paddr,
                  size_t          size,
                  const uint8_t * data,
                  const void    * in_supplement,
                  void          * out_supplement) :
            write_id_(write_id),
            paddr_(paddr),
            size_(size),
            stored_value_(size),
            prev_value_(size)
        {
            (void) in_supplement;
            (void) out_supplement;
 
            // Cache the memory being written to eventually be committed
            ::memcpy(stored_value_.data(), data, size);
        }
 
        uint64_t getWriteID() const { return write_id_; }
 
        addr_t   getPAddr()   const { return paddr_; }
 
        size_t   getSize()    const { return size_;  }
 
        uint8_t * getStoreDataPtr() { return stored_value_.data(); }
 
        uint8_t * getPrevDataPtr()  { return prev_value_.data(); }
 
        const uint8_t * getStoreDataPtr() const { return stored_value_.data(); }
 
        const uint8_t * getPrevDataPtr()  const { return prev_value_.data(); }
 
    private:
        const uint64_t       write_id_; 
        const addr_t         paddr_;  
        const size_t         size_;   
        std::vector<uint8_t> stored_value_;
        std::vector<uint8_t> prev_value_;
    };
 
    inline std::ostream & operator<<(std::ostream & os, const StoreData & mstore)
    {
        os << std::hex << "wid:" << mstore.getWriteID() << " pa:" << mstore.getPAddr()
           << std::dec << " size:" << mstore.getSize();
        return os;
    }
 
    template<class MemoryWriteType = StoreData>
    class CachedMemory : public sparta::memory::BlockingMemoryIF
    {
    public:
        CachedMemory(const std::string & name,
                     uint64_t write_id,
                     uint32_t outstanding_writes_watermark,
                     addr_t   block_size,
                     addr_t   total_size,
                     sparta::memory::BlockingMemoryIF * downstream_memory);
 
        uint64_t getWriteID() const { return write_id_; }
 
        const std::map<uint64_t, MemoryWriteType> & getOutstandingWrites() const {
            return outstanding_writes_;
        }
 
        std::vector<MemoryWriteType> getOutstandingWritesForAddr(addr_t paddr) const;
 
        uint32_t getNumOutstandingWrites() const { return outstanding_writes_.size(); }
 
        void commitWrite(const MemoryWriteType & write_to_commit);
 
        void mergeWrite(addr_t paddr, addr_t size, const uint8_t * buf);
 
        void dropWrite(const MemoryWriteType & write_to_drop);
 
        const MemoryWriteType & getLastOutstandingWrite() const {
            sparta_assert(false == outstanding_writes_.empty());
            return outstanding_writes_.rbegin()->second;
        }
 
    private:
        // State
        const uint64_t write_id_;
        const uint32_t outstanding_writes_watermark_;
        std::map<uint64_t, MemoryWriteType> outstanding_writes_;
        uint64_t write_uid_ = 0;
 
        // Derived methods
        bool tryRead_(addr_t paddr, addr_t size, uint8_t *buf,
                      const void *in_supplement, void *out_supplement) override final;
        bool tryWrite_(addr_t paddr, addr_t size, const uint8_t *buf,
                       const void *in_supplement, void *out_supplement) override final;
        bool tryPeek_(addr_t paddr, addr_t size,
                      uint8_t *buf) const override final;
        bool tryPoke_(addr_t paddr, addr_t size, const uint8_t *buf) override final;
 
        // Memory
        sparta::memory::BlockingMemoryIF * downstream_memory_ = nullptr;
        sparta::memory::MemoryObject       cached_memory_;
 
    };
 
    template<class MemoryWriteType>
    CachedMemory<MemoryWriteType>::CachedMemory(const std::string & name,
                                                uint64_t write_id,
                                                uint32_t outstanding_writes_watermark,
                                                addr_t block_size,
                                                addr_t total_size,
                                                sparta::memory::BlockingMemoryIF * downstream_memory) :
        sparta::memory::BlockingMemoryIF (name + "_cached_memory", block_size,
                                          sparta::memory::DebugMemoryIF::AccessWindow(0, total_size)),
        write_id_(write_id),
        outstanding_writes_watermark_(outstanding_writes_watermark),
        // Use the write ID at the top byte for uniquenes
        write_uid_(uint64_t(write_id_) << ((sizeof(write_uid_) - 1) * 8)),
        downstream_memory_(downstream_memory),
        cached_memory_(nullptr, block_size, total_size, 0)
    {}
 
    // Reads always occur on the cached memory.  If it "misses," data
    // will be peeked from downsteam memory but not read loaded into
    // the cached memory.  The cached memory does not maintain notions
    // of RWITM, etc
    template<class MemoryWriteType>
    bool CachedMemory<MemoryWriteType>::tryRead_ (addr_t paddr, addr_t size, uint8_t *buf,
                                                  const void *in_supplement, void *out_supplement)
    {
        if(cached_memory_.tryGetLine(paddr) == nullptr) {
            downstream_memory_->peek(paddr, size, buf);
        }
        else {
            cached_memory_.read(paddr, size, buf);
        }
        return true;
    }
 
    // Writes always occur on the cached memory.  If not present, the
    // data will first be loaded into the cache and the write merged
    template<class MemoryWriteType>
    bool CachedMemory<MemoryWriteType>::tryWrite_ (addr_t paddr, addr_t size, const uint8_t *buf,
                                                   const void *in_supplement, void *out_supplement)
    {
        sparta_assert(outstanding_writes_.size() != outstanding_writes_watermark_,
                      "Watermark of outstanding writes reached. "
                      "Writes need to be committed or dropped via the CoSim API");
 
        if(cached_memory_.tryGetLine(paddr) == nullptr) {
            // This block has not been initialized in cached memory yet because
            // it has not been written to before.
            const auto aligned_paddr = paddr & block_mask_;
            uint8_t * cached_mem_block_ptr = cached_memory_.getLine(aligned_paddr).getRawDataPtr(0);
            downstream_memory_->peek(aligned_paddr, block_size_, cached_mem_block_ptr);
        }
 
        // Store the write into a outstanding chain
        ++write_uid_;
 
        MemoryWriteType outstanding_write(write_uid_, paddr, size, buf, in_supplement, out_supplement);
        auto * prev_data_store = outstanding_write.getPrevDataPtr();
 
        // Need to get the previous value of memory to restore if the write is dropped
        cached_memory_.read(paddr, size, prev_data_store);
 
        // Write the new value of memory
        cached_memory_.write(paddr, size, buf);
 
        // Store the write
        outstanding_writes_.emplace(std::make_pair(write_uid_, outstanding_write));
 
        return true;
    }
 
    // Peeks will always occur on the cached memory as reads.  If the
    // data is not in the cache, downsteam memory is peeked instead
    template<class MemoryWriteType>
    bool CachedMemory<MemoryWriteType>::tryPeek_(addr_t paddr, addr_t size, uint8_t *buf) const
    {
        // Need to check for CI space or possibly magic memory address
        if(cached_memory_.tryGetLine(paddr) == nullptr) {
            downstream_memory_->peek(paddr, size, buf);
        }
        else {
            cached_memory_.read(paddr, size, buf);
        }
        return true;
    }
 
    // Pokes will always occur on the cached memory and downstream memory.
    template<class MemoryWriteType>
    bool CachedMemory<MemoryWriteType>::tryPoke_(addr_t paddr, addr_t size, const uint8_t *buf)
    {
        if(cached_memory_.tryGetLine(paddr) == nullptr) {
            // This memory was never written (or read) before.
            const auto aligned_paddr = paddr & block_mask_;
            uint8_t * cached_mem_block_ptr = cached_memory_.getLine(aligned_paddr).getRawDataPtr(0);
            downstream_memory_->poke(aligned_paddr, block_size_, cached_mem_block_ptr);
        }
        cached_memory_.write(paddr, size, buf);
        downstream_memory_->poke(paddr, size, buf);
        return true;
    }
 
    template<class MemoryWriteType>
    std::vector<MemoryWriteType>
    CachedMemory<MemoryWriteType>::getOutstandingWritesForAddr(addr_t paddr) const
    {
        std::vector<MemoryWriteType> matching_stores;
        for(const auto & [wuid, maw] : outstanding_writes_) {
            if((paddr >= maw.getPAddr()) && (paddr < (maw.getPAddr() + maw.getSize()))) {
                // This store access contains the given paddr
                matching_stores.emplace_back(maw);
            }
        }
        return matching_stores;
    }
 
    template<class MemoryWriteType>
    void CachedMemory<MemoryWriteType>::commitWrite(const MemoryWriteType & write_to_commit)
    {
        sparta_assert(false == outstanding_writes_.empty(),
                      "there are no outstanding writes for commit");
 
        const auto & mem_write_access = outstanding_writes_.begin()->second;
 
        if(SPARTA_EXPECT_FALSE(mem_write_access.getWriteID() != write_to_commit.getWriteID()))
        {
            std::stringstream msg;
            msg << __FUNCTION__ << ": error: attempting to commit write out of order: " << write_to_commit
                << " expected to commit write: " << mem_write_access;
            msg << "\nOutstanding writes for write ID " << write_id_ << " (oldest to newest):\n";
            for(const auto & outstanding_write : outstanding_writes_) {
                msg << "\t" << outstanding_write << "\n";
            }
            throw SpartaException(msg.str());
        }
 
        // Update downstream memory
        downstream_memory_->tryWrite(mem_write_access.getPAddr(),
                                     mem_write_access.getSize(),
                                     mem_write_access.getStoreDataPtr(), (void*)this);
        outstanding_writes_.erase(outstanding_writes_.begin());
    }
 
    template<class MemoryWriteType>
    void CachedMemory<MemoryWriteType>::dropWrite(const MemoryWriteType & write_to_drop)
    {
        sparta_assert(false == outstanding_writes_.empty(),
                      "There are no outstanding writes for dropping");
 
        if(SPARTA_EXPECT_FALSE(outstanding_writes_.find(write_to_drop.getWriteID()) == outstanding_writes_.end()))
        {
            std::stringstream msg;
            msg << __FUNCTION__ << ": error: attempting to drop a write that is not known by this CachedMemory: "
                << write_to_drop;
            msg << "\nOutstanding writes for write ID " << write_id_ << " (oldest to newest):\n";
            for(const auto & outstanding_writes : outstanding_writes_) {
                msg << "\t" << outstanding_writes << "\n";
            }
            throw SpartaException(msg.str());
        }
 
        // Drop all the writes from the newest up to and including the
        // dropped write
        auto currently_flushing_write = outstanding_writes_.rbegin();
        while(currently_flushing_write != outstanding_writes_.rend())
        {
            const uint64_t current_flushed_wuid = currently_flushing_write->first;
            const auto & current_flushed_maw = currently_flushing_write->second;
            cached_memory_.write(current_flushed_maw.getPAddr(),
                                 current_flushed_maw.getSize(),
                                 current_flushed_maw.getPrevDataPtr());
 
            // Drop the write
            outstanding_writes_.erase((++currently_flushing_write).base());
 
            if(current_flushed_wuid == write_to_drop.getWriteID()) {
                break;
            }
 
            currently_flushing_write = outstanding_writes_.rbegin();
        }
    }
 
    template<class MemoryWriteType>
    void CachedMemory<MemoryWriteType>::mergeWrite(addr_t paddr, addr_t size, const uint8_t * buf)
    {
        if(getNumOutstandingWrites() > 0) {
            // Brute force method, but works.  Take one byte at a time and
            // look for collisions.  If there are any, don't store it, but
            // update that outstanding store's previous value.  Start with
            // the oldest write and move to the newest.
            for(addr_t byte = 0; byte < size; ++byte)
            {
                const auto paddr_offset = paddr + byte;
                bool collision = false;
                for(auto & [wuid, maw] : outstanding_writes_)
                {
                    const auto maw_start_paddr = maw.getPAddr();
                    const auto maw_size  = maw.getSize();
                    if((paddr_offset >= maw_start_paddr) && (paddr_offset < (maw_start_paddr + maw_size)))
                    {
                        // Found a collision with this byte.  Update the
                        // previous value with the merge data
                        collision = true;
                        const uint32_t maw_byte = paddr_offset - maw_start_paddr;
                        maw.getPrevDataPtr()[maw_byte] = *(buf + byte);
                        break;
                    }
                }
                if(!collision) {
                    // Write the one byte of data -- no collisions
                    cached_memory_.write(paddr_offset, 1, buf + byte);
                }
            }
        }
        else {
            cached_memory_.write(paddr, size, buf);
        }
    }
 
 
}