SimpleMemoryMapNode.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "sparta/memory/BlockingMemoryIFNode.hpp"
#include "sparta/memory/SimpleMemoryMap.hpp"
 
namespace sparta
{
    namespace memory
    {
        class SimpleMemoryMapNode : public BlockingMemoryIFNode, public SimpleMemoryMap
        {
        public:
 
            using BlockingMemoryIFNode::getBlockSize;
 
 
            SimpleMemoryMapNode() = delete;
 
            SimpleMemoryMapNode(sparta::TreeNode* parent,
                                const std::string& name,
                                const std::string& group,
                                group_idx_type group_idx,
                                const std::string& desc,
                                addr_t block_size,
                                addr_t total_size,
                                TranslationIF* transif=nullptr) :
                BlockingMemoryIFNode(parent, name, group, group_idx, desc,
                                     block_size,
                                     DebugMemoryIF::AccessWindow(0, total_size),
                                     transif),
                SimpleMemoryMap(block_size)
            { }
 
            SimpleMemoryMapNode(sparta::TreeNode* parent,
                                const std::string& name,
                                const std::string& desc,
                                addr_t block_size,
                                addr_t total_size,
                                TranslationIF* transif=nullptr) :
                SimpleMemoryMapNode(parent,
                                    name,
                                    sparta::TreeNode::GROUP_NAME_NONE,
                                    sparta::TreeNode::GROUP_IDX_NONE,
                                    desc,
                                    block_size,
                                    total_size,
                                    transif)
            { }
 
            virtual ~SimpleMemoryMapNode() {}
 
 
 
            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)){
                    verifyHasMapping(addr, size);
                    verifyNoBlockSpan(addr, size);
                    verifyInAccessWindows(addr, size);
                    throw MemoryReadError(addr, size, "Unknown reason");
                }
            }
 
            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)){
                    verifyHasMapping(addr, size);
                    verifyNoBlockSpan(addr, size);
                    verifyInAccessWindows(addr, size);
                    throw MemoryReadError(addr, size, "Unkonwn reason");
                }
            }
 
 
 
            DMIBlockingMemoryIF *getDMI(addr_t addr, addr_t size) override {
                const Mapping * m = findMapping(addr);
                if(!m) {
                    return nullptr;
                }
                return m->memif->getDMI(m->mapAddress(addr), size);
            }
 
 
        protected:
 
 
            virtual bool tryRead_(addr_t addr,
                                  addr_t size,
                                  uint8_t *buf,
                                  const void *in_supplement=nullptr,
                                  void *out_supplement=nullptr) override {
                const Mapping* m = findMapping(addr);
                if(!m){
                    return false;
                    //throw MemoryReadError(addr, size, "Could not find mapping at this address");
                }
                return m->memif->tryRead(m->mapAddress(addr), size, buf, in_supplement, out_supplement);
            }
 
            virtual bool tryWrite_(addr_t addr,
                                   addr_t size,
                                   const uint8_t *buf,
                                   const void *in_supplement=nullptr,
                                   void *out_supplement=nullptr) override {
                Mapping* m = findMapping(addr);
                if(!m){
                    return false;
                    //throw MemoryWriteError(addr, size, "Could not find mapping at this address");
                }
                return m->memif->tryWrite(m->mapAddress(addr), size, buf, in_supplement, out_supplement);
            }
 
            virtual bool tryPeek_(addr_t addr,
                                  addr_t size,
                                  uint8_t *buf) const override {
                // Note that input peeks are already split into blocks, so each
                // may be translated once. Easy. Recall that peek has no
                // performance requirement either.
 
                const Mapping* m = findMapping(addr);
                if(!m){
                    return false;
                }
                return m->memif->tryPeek(m->mapAddress(addr), size, buf);
            }
 
            virtual bool tryPoke_(addr_t addr,
                                  addr_t size,
                                  const uint8_t *buf) override {
                // Note that input peeks are already split into blocks, so each
                // may be translated once. Easy. Recall that peek has no
                // performance requirement either.
 
                Mapping* m = findMapping(addr);
                if(!m){
                    return false;
                }
                return m->memif->tryPoke(m->mapAddress(addr), size, buf);
            }
 
 
        }; // class SimpleMemoryMapNode
    } // namespace memory
} // namespace sparta