DebugMemoryIF.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <math.h>
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/memory/MemoryExceptions.hpp"
#include "sparta/memory/TranslationIF.hpp"
#include "sparta/memory/AddressTypes.hpp"
#include "sparta/utils/StringManager.hpp"
#include "sparta/utils/Utils.hpp"
 
namespace sparta
{
    namespace memory
    {
        class DebugMemoryIF
        {
        public:
 
 
            struct AccessWindow {
 
                AccessWindow() = delete;
                AccessWindow& operator=(const AccessWindow&) = delete;
 
                AccessWindow(const AccessWindow&) = default;
 
                AccessWindow(addr_t _start,
                             addr_t _end,
                             const std::string& _name="default") :
                    start(_start), end(_end), name(_name)
                {
                    if(start >= end){
                        throw SpartaException("Cannot construct a Memory AccessWindow \"")
                            << name << "\" where start address (0x"
                            << std::hex << start << ") >= end address (0x" << end << ")";
                    }
                }
 
                bool containsAddr(addr_t addr) const noexcept {
                    return addr >= start && addr < end;
                }
 
                const addr_t start;
 
                const addr_t end;
 
                const std::string name;
            };
 
 
 
            DebugMemoryIF() = delete;
 
            DebugMemoryIF(const std::string& desc,
                          addr_t block_size,
                          const AccessWindow& window,
                          TranslationIF* transif=nullptr) :
                block_size_(block_size),
                block_mask_(0),
                block_idx_lsb_(0),
                acc_windows_({window}),
                trans_(transif),
                desc_ptr_(StringManager::getStringManager().internString(desc))
                // total_range_, low_end_, high_end_, and accessible_size_ are initialized in body
            {
                // Validate block_size
                if(block_size_ == 0){
                    throw SpartaException("0 block size specified for DebugMemoryIF: ")
                        << desc;
                }
 
                if(isPowerOf2(block_size_) == false){
                    throw SpartaException("block size (")
                        << block_size_ << ") specified is not a power of 2 for DebugMemoryIF: "
                        << desc;
                }
 
                // Compute block mask / idx_lsb
                block_idx_lsb_ = (addr_t)log2(block_size);
                block_mask_ = ~(((addr_t)1 << block_idx_lsb_) - 1);
                sparta_assert(((addr_t)1 << block_idx_lsb_) == block_size_);
 
                // Validate access windows
 
                if(acc_windows_.size() == 0){
                    throw SpartaException("0 access windows specified for DebugMemoryIF: ")
                        << desc;
                }
 
 
                low_end_ = acc_windows_[0].start;
                high_end_ = acc_windows_[0].end;
 
                // Check window block alignment
                for(const auto& win : acc_windows_){
                    if(win.start % block_size != 0){
                        throw SpartaException("Memory AccessWindow start address was not block-size (")
                            << block_size << ") aligned. Was " << std::hex << win.start;
                    }
                    if(win.end % block_size != 0){
                        throw SpartaException("Memory AccessWindow end address was not block-size (")
                            << block_size << ") aligned. Was " << std::hex << win.end;
                    }
 
                    if(win.start < low_end_){
                        low_end_ = win.start;
                    }
                    if(win.end > high_end_){
                        high_end_ = win.end;
                    }
                }
 
                sparta_assert(acc_windows_.size() == 1); // Assumption for the following code
                total_range_ = acc_windows_[acc_windows_.size()-1].end - acc_windows_[0].start;
                accessible_size_ = total_range_; // For a single window
            }
 
            virtual ~DebugMemoryIF() {}
 
 
 
            virtual const TranslationIF* getTranslationIF() {
                return trans_;
            }
 
 
 
            const std::string& getDescription() { return *desc_ptr_; };
 
            addr_t getBlockSize() const { return block_size_; }
 
            addr_t getRange() const { return total_range_; }
 
            addr_t getLowEnd() const { return low_end_; }
 
            addr_t getHighEnd() const { return high_end_; }
 
            addr_t getAccessibleSize() const { return accessible_size_; } // sum of all window sizes
 
            const std::vector<AccessWindow>& getWindows() const {
                return acc_windows_;
            }
 
 
 
            bool isAddressInWindows(addr_t addr) const noexcept {
                for(const auto& win : acc_windows_){
                    if(win.containsAddr(addr)){
                        return true;
                    }
                }
                return false;
            }
 
            void verifyInAccessWindows(addr_t addr, addr_t size) const {
                // Assumes 1 access window
                sparta_assert(acc_windows_.size() == 1); // This code is invalid once more than 1 window is supported
                if(__builtin_expect(addr < acc_windows_[0].start || addr+size > acc_windows_[0].end, 0)){
                    MemoryAccessError ex(addr, size, "any", "The access at does not fit within access windows: ");
                    ex << "{ [" << acc_windows_[0].start << "," << acc_windows_[0].end << ") }";
                    throw ex;
                }
            }
 
            bool isInAccessWindows(addr_t addr, addr_t size) const {
                // Assumes 1 access window
                sparta_assert(acc_windows_.size() == 1); // This code is invalid once more than 1 window is supported
                return addr >= acc_windows_[0].start && addr+size <= acc_windows_[0].end;
            }
 
            void verifyNoBlockSpan(addr_t addr, addr_t size) const {
                sparta_assert(size > 0);
                if(__builtin_expect(doesAccessSpan(addr,size), 0)){
                    throw MemoryAccessError(addr, size, "any", "The access spans blocks");
                }
            }
 
            bool doesAccessSpan(addr_t addr, addr_t size) const noexcept {
                return (addr & block_mask_) != ((addr + size - 1) & block_mask_);
            }
 
 
 
            bool tryPeek(addr_t addr,
                         addr_t size,
                         uint8_t *buf) const {
                if(false == __builtin_expect(isInAccessWindows(addr, size), 0)){
                    return false;
                }
 
                uint8_t* out = buf;
                addr_t a = addr;
                const addr_t end = addr + size;
                while(1){
                    addr_t block_end = block_mask_ & (a + block_size_);
                    if(block_end >= end){
                        return tryPeek_(a, end - a, out);
                    }
 
                    addr_t size_in_block = block_end - a;
                    if(!tryPeek_(a, size_in_block, out)){
                        return false;
                    }
                    out += size_in_block;
                    a = block_end;
                }
            }
 
            void peek(addr_t addr,
                      addr_t size,
                      uint8_t *buf) const {
                if(!tryPeek(addr, size, buf)){
                    verifyInAccessWindows(addr, size);
                    throw MemoryPeekError(addr, size, "Cannot peek memory");
                }
            }
 
            bool tryPoke(addr_t addr,
                         addr_t size,
                         const uint8_t *buf) {
                if(false == __builtin_expect(isInAccessWindows(addr, size), 0)){
                    return false;
                }
 
                const uint8_t* in = buf;
                addr_t a = addr;
                const addr_t end = addr + size;
                while(1){
                    addr_t block_end = block_mask_ & (a + block_size_);
                    if(block_end >= end){
                        return tryPoke_(a, end - a, in);
                    }
 
                    addr_t size_in_block = block_end - a;
                    if(!tryPoke_(a, size_in_block, in)){
                        return false;
                    }
                    in += size_in_block;
                    a = block_end;
                }
            }
 
            void poke(addr_t addr,
                      addr_t size,
                      const uint8_t *buf) {
                if(!tryPoke(addr, size, buf)){
                    verifyInAccessWindows(addr, size);
                    throw MemoryPokeError(addr, size, "Cannot poke memory");
                }
            }
 
 
        protected:
 
            const addr_t block_size_;
 
            addr_t block_mask_;
 
            addr_t block_idx_lsb_;
 
            const std::vector<AccessWindow> acc_windows_;
 
            TranslationIF* trans_;
 
            const std::string* const desc_ptr_;
 
            addr_t total_range_;
 
            addr_t low_end_;
 
            addr_t high_end_;
 
            addr_t accessible_size_;
 
 
        private:
 
            virtual bool tryPeek_(addr_t addr,
                                  addr_t size,
                                  uint8_t *buf) const = 0;
 
            virtual bool tryPoke_(addr_t addr,
                                  addr_t size,
                                  const uint8_t *buf) = 0;
 
        }; // class DebugMemoryIF
    } // namespace memory
} // namespace sparta