MemoryObject.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/memory/MemoryExceptions.hpp"
#include "sparta/memory/AddressTypes.hpp"
#include "sparta/memory/BlockingMemoryIFNode.hpp"
#include "sparta/memory/DMIBlockingMemoryIF.hpp"
#include "sparta/functional/ArchData.hpp"
#include "sparta/utils/Utils.hpp"
 
namespace sparta
{
    namespace memory
    {
        class MemoryObject : public ArchData
        {
        public:
 
 
            MemoryObject() = delete;
 
            MemoryObject(TreeNode* owner_node,
                         addr_t block_size,
                         addr_t total_size,
                         uint64_t fill=0xcc,
                         uint16_t fill_val_size=1) :
                ArchData(owner_node, block_size, fill, fill_val_size)
            {
                // ArchData ctor validates block_size as power of 2
                if(block_size == 0){
                    throw SpartaException("Cannot construct a Memoryobject with a block size of 0. Must be a power of 2 and greater than 0");
                }
 
                if(total_size == 0){
                    throw SpartaException("Cannot construct a Memoryobject with a total size of 0. Must be a multiple of block_size and greater than 0");
                }
 
                if(total_size % block_size != 0){
                    throw SpartaException("Cannot construct a MemoryObject with total_size = ")
                        << total_size << " which is not an even muliple of block_size (" << block_size << ")";
                }
 
                // Perform the layout. At this point, no further resizing can be done
                ArchData::layoutRange(total_size);
            }
            MemoryObject(TreeNode* owner_node, {…}
 
            virtual ~MemoryObject() {}
 
            virtual std::string stringize(bool pretty=false) const {
                (void) pretty;
                std::stringstream ss;
                ss << "<MemoryObject size:0x" << std::hex << getSize() << " bytes, "
                   << std::dec << getNumBlocks() << " blocks, "
                   << getNumAllocatedLines() << " blocks realized>";
                return ss.str();
            }
            virtual std::string stringize(bool pretty=false) const  {…}
 
 
 
            void read(addr_t addr,
                      addr_t size,
                      uint8_t *buf) const {
                // Address validation performed in tryGetLine
                const ArchData::Line* l = ArchData::tryGetLine(addr);
                if(!l){
                    checkCanAccess(addr, size); // Acts as if performing a read/write and throws on failure
                    ArchData::fillValue(buf,
                                        size,
                                        getFill(), // Initialze val with default fill
                                        getFillPatternSize(),
                                        (addr % getBlockSize()) % getFillPatternSize()); // Adjust for misalignment with fill pattern. block size is power of 2.
                }else{
                    // Size validation performed in read
                    l->read(addr - l->getOffset(), size, buf);
                }
            }
            void read(addr_t addr, {…}
 
            void write(addr_t addr,
                       addr_t size,
                       const uint8_t *buf) {
                // Address validation performed in getLine
                ArchData::Line& l = ArchData::getLine(addr);
 
                // Access size validation performed in write
                l.write(addr - l.getOffset(), size, buf);
            }
            void write(addr_t addr, {…}
 
 
 
            void _lookupAndValidate(addr_t addr,
                                    addr_t size,
                                    uint8_t *buf) const {
                (void) buf;
                const ArchData::Line* l = ArchData::tryGetLine(addr);
                (void) l;
                checkCanAccess(addr, size); // Acts as if performing a read/write and throws on failure
            }
            void _lookupAndValidate(addr_t addr, {…}
 
 
            void _canAccess(addr_t addr,
                            addr_t size,
                            uint8_t *buf) const {
                (void) buf;
                checkCanAccess(addr, size);
            }
            void _canAccess(addr_t addr, {…}
 
 
 
            addr_t getNumBlocks() const {
                return ArchData::getLineIndex(ArchData::getSize());
            };
            addr_t getNumBlocks() const  {…}
 
            addr_t getBlockSize() const {
                return ArchData::getLineSize();
            }
 
            uint64_t getFill() const {
                return ArchData::getInitial();
            }
            uint64_t getFill() const  {…}
 
            uint16_t getFillPatternSize() const {
                return ArchData::getInitialValSize();
            }
            uint16_t getFillPatternSize() const  {…}
 
        }; // class DebugMemoryIF
        class MemoryObject : public ArchData {…};
 
 
        class BlockingMemoryObjectIFNode : public BlockingMemoryIFNode
        {
            MemoryObject& binding_; 
 
        public:
 
            BlockingMemoryObjectIFNode(sparta::TreeNode* parent,
                                       const std::string& name,
                                       const std::string& group,
                                       sparta::TreeNode::group_idx_type group_idx,
                                       const std::string& desc,
                                       TranslationIF* transif,
                                       MemoryObject& binding) :
                BlockingMemoryIFNode(parent, name, group, group_idx, desc,
                                     binding.getBlockSize(),
                                     DebugMemoryIF::AccessWindow(0,binding.getSize()),
                                     transif),
                binding_(binding)
            { }
            BlockingMemoryObjectIFNode(sparta::TreeNode* parent, {…}
 
            BlockingMemoryObjectIFNode(sparta::TreeNode* parent,
                                       const std::string& name,
                                       const std::string& desc,
                                       TranslationIF* transif,
                                       MemoryObject& binding) :
                BlockingMemoryObjectIFNode(parent,
                                           name,
                                           sparta::TreeNode::GROUP_NAME_NONE,
                                           sparta::TreeNode::GROUP_IDX_NONE,
                                           desc,
                                           transif,
                                           binding)
            { }
            BlockingMemoryObjectIFNode(sparta::TreeNode* parent, {…}
 
            virtual ~BlockingMemoryObjectIFNode() {}
 
            MemoryObject* getMemObj() { return &binding_; }
 
            DMIBlockingMemoryIF * getDMI(addr_t addr,
                                         addr_t size) override
            {
                if(doesAccessSpan(addr, size)) {
                    return nullptr;
                }
                const auto aligned_addr = addr & block_mask_;
                if(auto it = dmi_ifs_.find(aligned_addr); it != dmi_ifs_.end()) {
                    return it->second.get();
                }
 
                auto & line = binding_.getLine(aligned_addr);
                dmi_ifs_.insert({aligned_addr,
                                 std::unique_ptr<DMIBlockingMemoryIF>
                                 (new DMIBlockingMemoryIF(line.getRawDataPtr(0),
                                                          line.getOffset(),
                                                          line.getLayoutSize()))});
                return dmi_ifs_[aligned_addr].get();
            }
            DMIBlockingMemoryIF * getDMI(addr_t addr, {…}
 
            void invalidateAllDMI() override {
                for (auto & dmi_if : dmi_ifs_) {
                    dmi_if.second->clearValid();
                }
            }
            void invalidateAllDMI() override  {…}
 
        protected:
            virtual bool tryPeek_(addr_t addr,
                                  addr_t size,
                                  uint8_t *buf) const override {
                binding_.read(addr,size,buf);
                return true;
            }
            virtual bool tryPeek_(addr_t addr, {…}
 
            virtual bool tryPoke_(addr_t addr,
                                  addr_t size,
                                  const uint8_t *buf) override {
                binding_.write(addr,size,buf);
                return true;
            }
            virtual bool tryPoke_(addr_t addr, {…}
 
        private:
 
            virtual bool tryRead_(addr_t addr,
                                  addr_t size,
                                  uint8_t *buf,
                                  const void *in_supplement,
                                  void *out_supplement) override {
                (void) in_supplement;
                (void) out_supplement;
                binding_.read(addr, size, buf);
                return true;
            }
 
            virtual bool tryWrite_(addr_t addr,
                                   addr_t size,
                                   const uint8_t *buf,
                                   const void *in_supplement,
                                   void *out_supplement) override {
                (void) in_supplement;
                (void) out_supplement;
                binding_.write(addr, size, buf);
                return true;
            }
 
            std::map<addr_t, std::unique_ptr<DMIBlockingMemoryIF>> dmi_ifs_;
 
        }; // class BlockingMemoryIF
        class BlockingMemoryObjectIFNode : public BlockingMemoryIFNode {…};
 
    } // namespace memory
} // namespace sparta
 
inline std::ostream& operator<<(std::ostream& out, const sparta::memory::MemoryObject& mo) {
    out << mo.stringize();
    return out;
}
inline std::ostream& operator<<(std::ostream& out, const sparta::memory::MemoryObject& mo) {…}
 
inline std::ostream& operator<<(std::ostream& out, const sparta::memory::MemoryObject* mo) {
    if(nullptr == mo){
        out << "null";
    }else{
        out << mo->stringize();
    }
    return out;
}
inline std::ostream& operator<<(std::ostream& out, const sparta::memory::MemoryObject* mo) {…}