BlockingMemoryIFNode.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/statistics/Counter.hpp"
#include "sparta/statistics/StatisticSet.hpp"
#include "sparta/log/NotificationSource.hpp"
#include "sparta/memory/MemoryExceptions.hpp"
#include "sparta/memory/AddressTypes.hpp"
#include "sparta/memory/BlockingMemoryIF.hpp"
 
namespace sparta
{
    namespace memory
    {
        class BlockingMemoryIFNode : public sparta::TreeNode, public BlockingMemoryIF
        {
        public:
 
 
            struct ReadAccess {
 
                ReadAccess(DebugMemoryIF* _mem) :
                    mem(_mem),
                    addr(0),
                    size(0),
                    data(nullptr),
                    in_supplement(nullptr),
                    out_supplement(nullptr)
                { }
 
                DebugMemoryIF* const mem;
 
                addr_t addr;
 
                addr_t size;
 
                const uint8_t* data;
 
                const void* in_supplement;
 
                void* out_supplement;
            };
 
            struct PostWriteAccess {
 
                PostWriteAccess(DebugMemoryIF* _mem) :
                    mem(_mem),
                    addr(0),
                    size(0),
                    prior(nullptr),
                    tried(nullptr),
                    in_supplement(nullptr),
                    out_supplement(nullptr)
                { }
 
                DebugMemoryIF* const mem;
 
                addr_t addr;
 
                addr_t size;
 
                const uint8_t* prior;
 
                const uint8_t* tried;
 
                const void* in_supplement;
 
                void* out_supplement;
            };
 
            typedef NotificationSource<ReadAccess> ReadNotiSrc;           
            typedef NotificationSource<PostWriteAccess> PostWriteNotiSrc; 
 
 
 
            BlockingMemoryIFNode() = delete;
 
            BlockingMemoryIFNode(sparta::TreeNode* parent,
                                 const std::string& name,
                                 const std::string& group,
                                 group_idx_type group_idx,
                                 const std::string& desc,
                                 addr_t block_size,
                                 const DebugMemoryIF::AccessWindow& window,
                                 TranslationIF* transif=nullptr) :
                TreeNode(name, group, group_idx, desc),
                BlockingMemoryIF(desc, block_size, window, transif),
                prior_val_buffer_(new uint8_t[block_size]), // block_size assured nonzero from DebugMemoryIF ctor
                sset_(this),
                post_write_noti_(this, "post_write", "Notification immediately after the memory interface has been written", "post_write"),
                post_write_noti_data_(this),
                post_read_noti_(this, "post_read", "Notification immediately after the memory interface has been read", "post_read"),
                post_read_noti_data_(this)
            {
                if(!parent){
                    throw SpartaException("BlockingMemoryIFNode must be constructed with a non-null parent");
                }
                setExpectedParent_(parent);
 
                ctr_writes_ = &sset_.createCounter<sparta::Counter>("num_writes", "Number of writes attempted (num write calls)",
                                                                  sparta::Counter::COUNT_NORMAL);
                ctr_reads_ = &sset_.createCounter<sparta::Counter>("num_reads", "Number of reads attempted (num read calls)",
                                                                 sparta::Counter::COUNT_NORMAL);
 
                parent->addChild(this);
            }
 
            BlockingMemoryIFNode(sparta::TreeNode* parent,
                                 const std::string& name,
                                 const std::string& desc,
                                 addr_t block_size,
                                 const AccessWindow& window,
                                 TranslationIF* transif=nullptr) :
                BlockingMemoryIFNode(parent,
                                     name,
                                     sparta::TreeNode::GROUP_NAME_NONE,
                                     sparta::TreeNode::GROUP_IDX_NONE,
                                     desc,
                                     block_size,
                                     window,
                                     transif)
            { }
 
            virtual ~BlockingMemoryIFNode() {}
 
 
 
            PostWriteNotiSrc& getPostWriteNotificationSource() {
                return post_write_noti_;
            }
 
            ReadNotiSrc& getReadNotificationSource() {
                return post_read_noti_;
            }
 
 
 
            //bool isWriteValid(addr_t addr, addr_t size) const noexcept {
            //    return isWriteValid_(addr, size);
            //}
            //bool isReadValid(addr_t addr, addr_t size) const noexcept {
            //    return isReadValid_(addr, size);
            //}
 
 
 
            virtual bool tryRead(addr_t addr,
                                 addr_t size,
                                 uint8_t *buf,
                                 const void *in_supplement=nullptr,
                                 void *out_supplement=nullptr) override {
                ++*ctr_reads_;
                if(__builtin_expect(doesAccessSpan(addr, size), 0)){
                    //BlockingMemoryIF base class seems to imply that throwing from a tryRead is invalid
                    //throw MemoryReadError(addr, size, "addr is in a different block than addr+size");
                    return false;
                }
                if(__builtin_expect(isInAccessWindows(addr, size) == false, 0)){
                    return false;
                }
                if(__builtin_expect(post_read_noti_.observed() == false, 1)){
                    return tryRead_(addr, size, buf, in_supplement, out_supplement); // Read and return if unobserved
                }
 
                bool result = tryRead_(addr, size, buf, in_supplement, out_supplement);
 
                if(result){
                    ReadNotiSrc::data_type post_read_noti_data(this);
                    post_read_noti_data.addr = addr;
                    post_read_noti_data.size = size;
                    post_read_noti_data.data = buf;
                    post_read_noti_data.in_supplement = in_supplement;
                    post_read_noti_.postNotification(post_read_noti_data);
                }
 
                return result;
            }
 
            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) override {
                ++*ctr_writes_;
                if(__builtin_expect(doesAccessSpan(addr, size), 0)){
                    // BlockingMemoryIF base class claims that tryRead and tryWrite cannot throw
                    // throw MemoryWriteError(addr, size, "addr is in a different block than addr+size");
                    return false;
                }
                if(__builtin_expect(isInAccessWindows(addr, size) == false, 0)){
                    return false;
                }
                if(__builtin_expect(post_write_noti_.observed() == false, 1)){
                    return tryWrite_(addr, size, buf, in_supplement, out_supplement); // Write and return if unobserved
                }
 
                // peek into block-size buffer
                if(!tryPeek(addr, size, prior_val_buffer_.get())){
                    return false;
                }
 
                bool result = tryWrite_(addr, size, buf, in_supplement, out_supplement);
 
                if(result){
                    PostWriteNotiSrc::data_type post_write_noti_data(this);
                    post_write_noti_data.addr = addr;
                    post_write_noti_data.size = size;
                    post_write_noti_data.prior = prior_val_buffer_.get();
                    post_write_noti_data.tried = buf;
                    post_write_noti_data.in_supplement = in_supplement;
                    // A getInternalBuffer method seems appropriate here but is
                    // not used because no assumptions should be made about
                    // storage. So Memory implementation may not HAVE an
                    // internal buffer for this memory (e.g. memory mapped registers not
                    // contiguous)
                    // Instead, caller must peek themselves.
                    post_write_noti_.postNotification(post_write_noti_data);
                }
 
                return result;
            }
 
            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");
                }
            }
 
 
 
            StatisticSet& getStatisticSet() {
                return sset_;
            }
 
            virtual std::string stringize(bool pretty=false) const override {
                (void) pretty;
                std::stringstream ss;
                ss << "<" << getLocation() << " size:0x" << std::hex << total_range_ << " bytes>";
                return ss.str();
            }
 
            std::unique_ptr<uint8_t[]> prior_val_buffer_;
 
 
            StatisticSet sset_;
            Counter* ctr_writes_;
            Counter* ctr_reads_;
 
 
            PostWriteNotiSrc post_write_noti_; 
            PostWriteNotiSrc::data_type post_write_noti_data_; 
            ReadNotiSrc post_read_noti_; 
            ReadNotiSrc::data_type post_read_noti_data_; 
 
        }; // class BlockingMemoryIFNode
    } // namespace memory
} // namespace sparta