Ignore:
Timestamp:
Aug 22, 2013, 6:45:38 PM (11 years ago)
Author:
haoliu
Message:

This version for RWT has merged with the lastest version of classic tsar.
It pass the test with giet_vm.

Location:
branches/RWT/modules/vci_mem_cache/caba/source/include
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/RWT/modules/vci_mem_cache/caba/source/include

  • branches/RWT/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

    r477 r495  
    66#include <cassert>
    77#include "arithmetics.h"
    8 
    9 // !!!
    10 // The L1_MULTI_CACHE mechanism does no longer work with the new pktid encoding
    11 // of TSAR. Turning the define below to a non null value will cause the memcache
    12 // to behave in an unpredicted way.
    13 // TODO Either remove the mechanism from the mem cache or update its behaviour.
    14 
    15 #define L1_MULTI_CACHE 0
    168
    179//#define RANDOM_EVICTION
    … …  
    4638      bool      inst;       // Is the owner an ICache ?
    4739      size_t    srcid;      // The SRCID of the owner
    48 #if L1_MULTI_CACHE
    49       size_t    cache_id;   // In multi_cache configuration
    50 #endif
    5140
    5241    ////////////////////////
    5342    // Constructors
    5443    ////////////////////////
    55       Owner(bool   i_inst
    56             ,size_t i_srcid
    57 #if L1_MULTI_CACHE
    58             ,size_t i_cache_id
    59 #endif
    60             ){
     44      Owner(bool   i_inst,
     45            size_t i_srcid)
     46      {
    6147        inst    = i_inst;
    6248        srcid   = i_srcid;
    63 #if L1_MULTI_CACHE
    64         cache_id= i_cache_id;
    65 #endif
    66       }
    67 
    68       Owner(const Owner &a){
     49      }
     50
     51      Owner(const Owner &a)
     52      {
    6953        inst    = a.inst;
    7054        srcid   = a.srcid;
    71 #if L1_MULTI_CACHE
    72         cache_id= a.cache_id;
    73 #endif
    74       }
    75 
    76       Owner(){
     55      }
     56
     57      Owner()
     58      {
    7759        inst    = false;
    7860        srcid   = 0;
    79 #if L1_MULTI_CACHE
    80         cache_id= 0;
    81 #endif
    8261      }
    8362      // end constructors
    … …  
    11695      owner.inst    = 0;
    11796      owner.srcid   = 0;
    118 #if L1_MULTI_CACHE
    119       owner.cache_id= 0;
    120 #endif
    12197      ptr           = 0;
    12298    }
    … …  
    177153                << " ; Count = " << count
    178154                << " ; Owner = " << owner.srcid
    179 #if L1_MULTI_CACHE
    180                 << "." << owner.cache_id
    181 #endif
    182155                << " " << owner.inst
    183156                << " ; Pointer = " << ptr << std::endl;
    … …  
    328301    // - entry : the entry value
    329302    /////////////////////////////////////////////////////////////////////
    330     void write(const size_t &set, const size_t &way, const DirectoryEntry &entry)
     303    void write( const size_t         &set,
     304                const size_t         &way,
     305                const DirectoryEntry &entry)
    331306    {
    332307      assert( (set<m_sets)
    … …  
    374349    DirectoryEntry select(const size_t &set, size_t &way)
    375350    {
    376       assert( (set < m_sets)
     351        assert( (set < m_sets)
    377352          && "Cache Directory : (select) The set index is invalid");
    378353
    379       for(size_t i=0; i<m_ways; i++){
    380         if(!m_dir_tab[set][i].valid){
    381           way=i;
    382           return DirectoryEntry(m_dir_tab[set][way]);
     354        // looking for an empty slot
     355        for(size_t i=0; i<m_ways; i++)
     356        {
     357            if( not m_dir_tab[set][i].valid )
     358            {
     359                way=i;
     360                return DirectoryEntry(m_dir_tab[set][way]);
     361            }
    383362        }
    384       }
    385363
    386364#ifdef RANDOM_EVICTION
    387       lfsr = (lfsr >> 1) ^ ((-(lfsr & 1)) & 0xd0000001);
    388       way = lfsr % m_ways;
    389       return DirectoryEntry(m_dir_tab[set][way]);
     365        lfsr = (lfsr >> 1) ^ ((-(lfsr & 1)) & 0xd0000001);
     366        way = lfsr % m_ways;
     367        return DirectoryEntry(m_dir_tab[set][way]);
    390368#endif
    391369
    392       for(size_t i=0; i<m_ways; i++){
    393         if(!(m_lru_tab[set][i].recent) && !(m_dir_tab[set][i].lock)){
    394           way=i;
    395           return DirectoryEntry(m_dir_tab[set][way]);
     370        // looking for a not locked and not recently used entry
     371        for(size_t i=0; i<m_ways; i++)
     372        {
     373            if((not m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock) )
     374            {
     375                way=i;
     376                return DirectoryEntry(m_dir_tab[set][way]);
     377            }
    396378        }
    397       }
    398       for(size_t i=0; i<m_ways; i++){
    399         if( !(m_lru_tab[set][i].recent) && (m_dir_tab[set][i].lock)){
    400           way=i;
    401           return DirectoryEntry(m_dir_tab[set][way]);
     379
     380        // looking for a locked not recently used entry
     381        for(size_t i=0; i<m_ways; i++)
     382        {
     383            if( (not m_lru_tab[set][i].recent) && (m_dir_tab[set][i].lock))
     384            {
     385                way=i;
     386                return DirectoryEntry(m_dir_tab[set][way]);
     387            }
    402388        }
    403       }
    404       for(size_t i=0; i<m_ways; i++){
    405         if( (m_lru_tab[set][i].recent) && !(m_dir_tab[set][i].lock)){
    406           way=i;
    407           return DirectoryEntry(m_dir_tab[set][way]);
     389
     390        // looking for a recently used entry not locked
     391        for(size_t i=0; i<m_ways; i++)
     392        {
     393            if( (m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock))
     394            {
     395                way=i;
     396                return DirectoryEntry(m_dir_tab[set][way]);
     397            }
    408398        }
    409       }
    410       way = 0;
    411       return DirectoryEntry(m_dir_tab[set][0]);
     399
     400        // select way 0 (even if entry is locked and recently used)
     401        way = 0;
     402        return DirectoryEntry(m_dir_tab[set][0]);
    412403    } // end select()
    413404
    … …  
    443434    ////////////////////////
    444435      HeapEntry()
    445       :owner(false,0
    446 #if L1_MULTI_CACHE
    447              ,0
    448 #endif
    449              )
     436      :owner(false,0)
    450437      {
    451438        next = 0;
    … …  
    455442    // Constructor
    456443    ////////////////////////
    457       HeapEntry(const HeapEntry &entry){
     444      HeapEntry(const HeapEntry &entry)
     445      {
    458446        owner.inst  = entry.owner.inst;
    459447        owner.srcid = entry.owner.srcid;
    460 #if L1_MULTI_CACHE
    461         owner.cache_id = entry.owner.cache_id;
    462 #endif       
    463448        next           = entry.next;
    464449      } // end constructor
    … …  
    467452    // The copy() function copies an existing source entry to a target
    468453    /////////////////////////////////////////////////////////////////////
    469       void copy(const HeapEntry &entry){
     454      void copy(const HeapEntry &entry)
     455      {
    470456        owner.inst     = entry.owner.inst;
    471457        owner.srcid    = entry.owner.srcid;
    472 #if L1_MULTI_CACHE
    473         owner.cache_id = entry.owner.cache_id;
    474 #endif
    475458        next           = entry.next;
    476459      } // end copy()
    … …  
    483466        << " -- owner.inst     : " << std::dec << owner.inst << std::endl
    484467        << " -- owner.srcid    : " << std::dec << owner.srcid << std::endl
    485 #if L1_MULTI_CACHE
    486         << " -- owner.cache_id : " << std::dec << owner.cache_id << std::endl
    487 #endif
    488468        << " -- next           : " << std::dec << next << std::endl;
    489469
    … …  
    646626  //                        Cache Data
    647627  ////////////////////////////////////////////////////////////////////////
    648   class CacheData {
     628  class CacheData
     629  {
    649630    private:
    650631      const uint32_t m_sets;
    … …  
    656637    public:
    657638
     639      ///////////////////////////////////////////////////////
    658640      CacheData(uint32_t ways, uint32_t sets, uint32_t words)
    659         : m_sets(sets), m_ways(ways), m_words(words) {
    660 
     641        : m_sets(sets), m_ways(ways), m_words(words)
     642      {
    661643          m_cache_data = new uint32_t ** [ways];
    662           for ( size_t i=0 ; i < ways ; i++ ) {
    663             m_cache_data[i] = new uint32_t * [sets];
     644          for ( size_t i=0 ; i < ways ; i++ )
     645          {
     646              m_cache_data[i] = new uint32_t * [sets];
    664647          }
    665           for ( size_t i=0; i<ways; i++ ) {
    666             for ( size_t j=0; j<sets; j++ ) {
    667               m_cache_data[i][j] = new uint32_t [words];
    668             }
     648          for ( size_t i=0; i<ways; i++ )
     649          {
     650              for ( size_t j=0; j<sets; j++ )
     651              {
     652                  m_cache_data[i][j] = new uint32_t [words];
     653              }
    669654          }
    670         }
    671 
    672       ~CacheData() {
    673           for(size_t i=0; i<m_ways ; i++){
    674               for(size_t j=0; j<m_sets ; j++){
     655      }
     656      ////////////
     657      ~CacheData()
     658      {
     659          for(size_t i=0; i<m_ways ; i++)
     660          {
     661              for(size_t j=0; j<m_sets ; j++)
     662              {
    675663                  delete [] m_cache_data[i][j];
    676664              }
    677665          }
    678           for(size_t i=0; i<m_ways ; i++){
     666          for(size_t i=0; i<m_ways ; i++)
     667          {
    679668              delete [] m_cache_data[i];
    680669          }
    681670          delete [] m_cache_data;
    682671      }
    683 
    684       uint32_t read (
    685           const uint32_t &way,
    686           const uint32_t &set,
    687           const uint32_t &word) const {
    688 
    689         assert((set  < m_sets ) && "Cache data error: Trying to read a wrong set" );
    690         assert((way  < m_ways ) && "Cache data error: Trying to read a wrong way" );
    691         assert((word < m_words) && "Cache data error: Trying to read a wrong word");
    692 
    693         return m_cache_data[way][set][word];
    694       }
    695 
    696       void read_line(
    697           const uint32_t &way,
    698           const uint32_t &set,
    699           sc_core::sc_signal<uint32_t> * cache_line)
    700       {
    701         assert((set < m_sets ) && "Cache data error: Trying to read a wrong set" );
    702         assert((way < m_ways ) && "Cache data error: Trying to read a wrong way" );
    703 
    704         for (uint32_t word=0; word<m_words; word++)
    705           cache_line[word].write(m_cache_data[way][set][word]);
    706       }
    707 
    708       void write (
    709           const uint32_t &way,
    710           const uint32_t &set,
    711           const uint32_t &word,
    712           const uint32_t &data,
    713           const uint32_t &be = 0xF) {
    714 
    715         assert((set  < m_sets ) && "Cache data error: Trying to write a wrong set" );
    716         assert((way  < m_ways ) && "Cache data error: Trying to write a wrong way" );
    717         assert((word < m_words) && "Cache data error: Trying to write a wrong word");
    718         assert((be  <= 0xF    ) && "Cache data error: Trying to write a wrong word cell");
    719 
    720         if (be == 0x0) return;
    721 
    722         if (be == 0xF) {
    723             m_cache_data[way][set][word] = data;
    724             return;
    725         }
    726 
    727         uint32_t mask = 0;
    728         if  (be & 0x1) mask = mask | 0x000000FF;
    729         if  (be & 0x2) mask = mask | 0x0000FF00;
    730         if  (be & 0x4) mask = mask | 0x00FF0000;
    731         if  (be & 0x8) mask = mask | 0xFF000000;
    732 
    733         m_cache_data[way][set][word] =
    734           (data & mask) | (m_cache_data[way][set][word] & ~mask);
     672      //////////////////////////////////////////
     673      uint32_t read ( const uint32_t &way,
     674                      const uint32_t &set,
     675                      const uint32_t &word) const
     676      {
     677          assert((set  < m_sets ) && "Cache data error: Trying to read a wrong set" );
     678          assert((way  < m_ways ) && "Cache data error: Trying to read a wrong way" );
     679          assert((word < m_words) && "Cache data error: Trying to read a wrong word");
     680
     681          return m_cache_data[way][set][word];
     682      }
     683      //////////////////////////////////////////
     684      void read_line( const uint32_t &way,
     685                      const uint32_t &set,
     686                      sc_core::sc_signal<uint32_t> * cache_line)
     687      {
     688          assert((set < m_sets ) && "Cache data error: Trying to read a wrong set" );
     689          assert((way < m_ways ) && "Cache data error: Trying to read a wrong way" );
     690
     691          for (uint32_t word=0; word<m_words; word++)
     692              cache_line[word].write(m_cache_data[way][set][word]);
     693      }
     694      /////////////////////////////////////////
     695      void write ( const uint32_t &way,
     696                   const uint32_t &set,
     697                   const uint32_t &word,
     698                   const uint32_t &data,
     699                   const uint32_t &be = 0xF)
     700      {
     701
     702          assert((set  < m_sets ) && "Cache data error: Trying to write a wrong set" );
     703          assert((way  < m_ways ) && "Cache data error: Trying to write a wrong way" );
     704          assert((word < m_words) && "Cache data error: Trying to write a wrong word");
     705          assert((be  <= 0xF    ) && "Cache data error: Trying to write a wrong be");
     706
     707          if (be == 0x0) return;
     708
     709          if (be == 0xF)
     710          {
     711              m_cache_data[way][set][word] = data;
     712              return;
     713          }
     714
     715          uint32_t mask = 0;
     716          if  (be & 0x1) mask = mask | 0x000000FF;
     717          if  (be & 0x2) mask = mask | 0x0000FF00;
     718          if  (be & 0x4) mask = mask | 0x00FF0000;
     719          if  (be & 0x8) mask = mask | 0xFF000000;
     720
     721          m_cache_data[way][set][word] =
     722              (data & mask) | (m_cache_data[way][set][word] & ~mask);
    735723      }
    736724  }; // end class CacheData
Note: See TracChangeset for help on using the changeset viewer.