TranslationIF.hpp

 
#pragma once
 
#include "sparta/memory/AddressTypes.hpp"
#include "sparta/memory/Translation.hpp"
#include "sparta/memory/MemoryExceptions.hpp"
 
namespace sparta
{
    namespace memory
    {
        class TranslationIF
        {
        public:
 
 
            TranslationIF& operator=(const TranslationIF&) = delete;
            TranslationIF(const TranslationIF&) = delete;
 
            TranslationIF(const std::string& input_type,
                          const std::string& output_type) :
                input_type_(input_type),
                output_type_(output_type)
            { }
 
            TranslationIF() :
                TranslationIF("virtual", "physical")
            { }
 
            virtual ~TranslationIF() {}
 
 
 
            const std::string& getInputType() const { return input_type_; }
 
            const std::string& getOutputType() const { return output_type_; }
 
 
 
            bool tryTranslate(const addr_t& addr, Translation* trans=nullptr) const {
                Translation local_trans;
                Translation& t(trans!=nullptr ? (*trans) : local_trans);
                if(!tryTranslate_(addr, t)){
                    // Determine failure cause.
                    // Check if failure is caused by out-of-range or block-spanning
                    // If not, why???
                    throw MemoryTranslationError(addr, "Cannot translate");
                }
                return true;
            }
 
            addr_t translate(const addr_t& addr, Translation* trans=nullptr) const {
                Translation local_trans;
                Translation& t(trans!=nullptr ? (*trans) : local_trans);
 
                if(!tryTranslate_(addr, t)){
                    // Check if failure is caused by out-of-range or block-spanning
                    // If not, why???
                    throw MemoryTranslationError(addr, "Cannot translate");
                }
                return t.getOutputAddress();
            }
 
 
        private:
 
            virtual bool tryTranslate_(const addr_t& addr, Translation& trans) const noexcept {
                trans = Translation(addr, addr);
                return true;
            }
 
            const std::string input_type_; 
            const std::string output_type_; 
 
        };
    } // namespace memory
} // namespace sparta