BlockingMemoryIF.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "sparta/memory/MemoryExceptions.hpp"
#include "sparta/memory/AddressTypes.hpp"
#include "sparta/memory/DebugMemoryIF.hpp"
 
namespace sparta
{
    namespace memory
    {
        class TranslationIF;
        class DMIBlockingMemoryIF;
 
        class BlockingMemoryIF : public sparta::memory::DebugMemoryIF
        {
        public:
 
 
 
            BlockingMemoryIF() = delete;
 
            BlockingMemoryIF(const std::string& desc,
                             addr_t block_size,
                             const DebugMemoryIF::AccessWindow& window,
                             TranslationIF* transif=nullptr) :
                DebugMemoryIF(desc, block_size, window, transif)
            { }
 
            virtual ~BlockingMemoryIF() {}
 
 
 
            virtual bool tryRead(addr_t addr,
                                 addr_t size,
                                 uint8_t *buf,
                                 const void *in_supplement=nullptr,
                                 void *out_supplement=nullptr) {
                if(__builtin_expect(doesAccessSpan(addr, size), 0)){
                    return false;
                    //throw MemoryReadError(addr, size, "addr is in a different block than addr+size");
                }
                if(__builtin_expect(isInAccessWindows(addr, size) == false, 0)){
                    return false;
                }
 
                return tryRead_(addr, size, buf, in_supplement, out_supplement);
            }
 
            void read(addr_t addr,
                      addr_t size,
                      uint8_t *buf,
                      const void *in_supplement=nullptr,
                      void *out_supplement=nullptr) {
                if(!tryRead(addr, size, buf, in_supplement, out_supplement)){
                    verifyNoBlockSpan(addr, size);
                    verifyInAccessWindows(addr, size);
                    throw MemoryReadError(addr, size, "Unknown reason");
                }
            }
 
            virtual bool tryWrite(addr_t addr,
                                  addr_t size,
                                  const uint8_t *buf,
                                  const void *in_supplement=nullptr,
                                  void *out_supplement=nullptr) {
                if(__builtin_expect(doesAccessSpan(addr, size), 0)){
                    return false;
                    //throw MemoryWriteError(addr, size, "addr is in a different block than addr+size");
                }
                if(__builtin_expect(isInAccessWindows(addr, size) == false, 0)){
                    return false;
                }
 
                return tryWrite_(addr, size, buf, in_supplement, out_supplement);
            }
 
            void write(addr_t addr,
                       addr_t size,
                       const uint8_t *buf,
                       const void *in_supplement=nullptr,
                       void *out_supplement=nullptr) {
                if(!tryWrite(addr, size, buf, in_supplement, out_supplement)){
                    verifyNoBlockSpan(addr, size);
                    verifyInAccessWindows(addr, size);
                    throw MemoryReadError(addr, size, "Unkonwn reason");
                }
            }
 
            virtual DMIBlockingMemoryIF * getDMI(addr_t addr, addr_t size)
            {
                return nullptr;
            }
 
            virtual void invalidateAllDMI() { return; }
 
 
            std::string stringize(bool pretty=false) const {
                (void) pretty;
                std::stringstream ss;
                ss << "<BlockingMemoryIF size:0x" << std::hex << total_range_ << " bytes>";
                return ss.str();
            }
 
        protected:
 
 
            virtual bool tryRead_(addr_t addr,
                                  addr_t size,
                                  uint8_t *buf,
                                  const void *in_supplement,
                                  void *out_supplement) = 0;
 
            virtual bool tryWrite_(addr_t addr,
                                   addr_t size,
                                   const uint8_t *buf,
                                   const void *in_supplement,
                                   void *out_supplement) = 0;
 
            virtual bool tryPoke_(addr_t addr,
                                  addr_t size,
                                  const uint8_t *buf) override {
                return tryWrite_(addr, size, buf, nullptr, nullptr);
            }
 
            //virtual bool isWriteValid_(addr_t addr, addr_t size) const noexcept = 0;
            //
            //virtual bool isReadValid_(addr_t addr, addr_t size) const noexcept = 0;
 
 
 
        }; // class BlockingMemoryIF
    } // namespace memory
} // namespace sparta
 
 
inline std::ostream& operator<<(std::ostream& out, const sparta::memory::BlockingMemoryIF& mi) {
    out << mi.stringize();
    return out;
}
 
inline std::ostream& operator<<(std::ostream& out, const sparta::memory::BlockingMemoryIF* mi) {
    if(nullptr == mi){
        out << "null";
    }else{
        out << mi->stringize();
    }
    return out;
}