TLB.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// This file is part of ETISS. It is licensed under the BSD 3-Clause License; you may not use this file except in
// compliance with the License. You should have received a copy of the license along with this project. If not, see the
// LICENSE file.
#ifndef ETISS_INCLUDE_MM_TLB_H_
#define ETISS_INCLUDE_MM_TLB_H_
 
#include <map>
 
#include "etiss/mm/PageFaultVector.h"
#include "etiss/mm/PTE.h"
 
namespace etiss
{
namespace mm
{
 
template <uint32_t EntryNum>
class TLB
{
 
    typedef std::map<uint64_t, PTE> TLBMap;
 
  public:
    explicit TLB() : is_full_(false)
    {
 
        if (unlikely(0 == EntryNum))
            infinite_tlb_entries_ = true;
        else
            max_entry_ = EntryNum;
    }
 
    uint32_t AddPTE(uint64_t vfn, uint64_t pte_val)
    {
        if (unlikely(is_full_))
            return TLBISFULL;
        else if (tlb_map_.find(vfn) != tlb_map_.end())
            return PTEOVERLAP;
 
        tlb_map_[vfn] = PTE(pte_val);
 
        if (EntryNum == ++current_entry_num_)
            is_full_ = true;
        return NOERROR;
    }
 
    uint32_t AddPTE(uint64_t vfn, const PTE &pte_entry)
    {
        if (unlikely(is_full_))
            return TLBISFULL;
        else if (tlb_map_.find(vfn) != tlb_map_.end())
            return PTEOVERLAP;
 
        tlb_map_[vfn] = PTE(pte_entry);
 
        if (EntryNum == ++current_entry_num_)
            is_full_ = true;
        return NOERROR;
    }
 
    uint32_t Lookup(uint64_t vfn, PTE *pte_buf)
    {
        TLBMap::iterator itr = tlb_map_.find(vfn);
        // Debug
        // std::cout << "vfn in TLB: 0x" << std::hex << vfn << std::endl;
        if (itr == tlb_map_.end())
            return TLBMISS;
        *pte_buf = itr->second;
        return NOERROR;
    }
 
    inline void Flush()
    {
        tlb_map_.clear();
        current_entry_num_ = 0;
        if (is_full_)
            is_full_ = false;
    }
 
    uint32_t UpdatePTE(uint64_t vfn, uint64_t pte_val)
    {
        TLBMap::iterator itr = tlb_map_.find(vfn);
        if (unlikely(itr == tlb_map_.end()))
            return PTENOTEXISTED;
        itr->second.Update(pte_val);
        return NOERROR;
    }
 
    uint32_t EvictPTE(uint64_t vfn)
    {
        TLBMap::iterator itr = tlb_map_.find(vfn);
        if (unlikely(itr == tlb_map_.end()))
            return PTENOTEXISTED;
        tlb_map_.erase(itr);
        --current_entry_num_;
        is_full_ = false;
        return NOERROR;
    }
 
    inline bool IsFull() const { return is_full_; }
 
    void DumpEntry(uint64_t vfn)
    {
        TLBMap::iterator itr = tlb_map_.find(vfn);
        if (unlikely(itr == tlb_map_.end()))
        {
            etiss::log(etiss::ERROR, "No Virtual Memory Address (VMA) mapping existed");
            return;
        }
        std::cout << "Virtual Frame Number (VFN) : 0x" << std::hex << vfn << std::endl;
        itr->second.Dump();
        std::cout << "---------------------------" << std::endl;
        return;
    }
 
    void Dump()
    {
        using std::cout;
        using std::endl;
        TLBMap::const_iterator itr = tlb_map_.begin();
        std::cout << "----------TLB Details---------" << std::endl;
        cout << "TLB is full : " << std::boolalpha << is_full_ << endl;
        cout << "Total entry number in TLB : " << (infinite_tlb_entries_ ? "infinite" : std::to_string(max_entry_))
             << endl;
        cout << "TLB current entry number : " << current_entry_num_ << endl;
        for (; itr != tlb_map_.end(); ++itr)
            DumpEntry(itr->first);
        return;
    }
 
  private:
    TLBMap tlb_map_;
 
    uint32_t max_entry_;
    uint32_t current_entry_num_;
    bool is_full_;
    bool infinite_tlb_entries_;
};
 
} // namespace mm
} // namespace etiss
 
#endif