Ignore:
Timestamp:
Aug 9, 2013, 11:00:05 AM (11 years ago)
Author:
alain
Message:

Implement both the SYNC and INVAL configuration commands.
Uses the TRT to transmit the cache line to XRAM in cPUT transactions.
Improve the debug.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

    r449 r489  
    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
    … …  
    11493      owner.inst    = 0;
    11594      owner.srcid   = 0;
    116 #if L1_MULTI_CACHE
    117       owner.cache_id= 0;
    118 #endif
    11995      ptr           = 0;
    12096    }
    … …  
    171147                << " ; Count = " << count
    172148                << " ; Owner = " << owner.srcid
    173 #if L1_MULTI_CACHE
    174                 << "." << owner.cache_id
    175 #endif
    176149                << " " << owner.inst
    177150                << " ; Pointer = " << ptr << std::endl;
    … …  
    322295    // - entry : the entry value
    323296    /////////////////////////////////////////////////////////////////////
    324     void write(const size_t &set, const size_t &way, const DirectoryEntry &entry)
     297    void write( const size_t         &set,
     298                const size_t         &way,
     299                const DirectoryEntry &entry)
    325300    {
    326301      assert( (set<m_sets)
    … …  
    368343    DirectoryEntry select(const size_t &set, size_t &way)
    369344    {
    370       assert( (set < m_sets)
     345        assert( (set < m_sets)
    371346          && "Cache Directory : (select) The set index is invalid");
    372347
    373       for(size_t i=0; i<m_ways; i++){
    374         if(!m_dir_tab[set][i].valid){
    375           way=i;
    376           return DirectoryEntry(m_dir_tab[set][way]);
     348        // looking for an empty slot
     349        for(size_t i=0; i<m_ways; i++)
     350        {
     351            if( not m_dir_tab[set][i].valid )
     352            {
     353                way=i;
     354                return DirectoryEntry(m_dir_tab[set][way]);
     355            }
    377356        }
    378       }
    379357
    380358#ifdef RANDOM_EVICTION
    381       lfsr = (lfsr >> 1) ^ ((-(lfsr & 1)) & 0xd0000001);
    382       way = lfsr % m_ways;
    383       return DirectoryEntry(m_dir_tab[set][way]);
     359        lfsr = (lfsr >> 1) ^ ((-(lfsr & 1)) & 0xd0000001);
     360        way = lfsr % m_ways;
     361        return DirectoryEntry(m_dir_tab[set][way]);
    384362#endif
    385363
    386       for(size_t i=0; i<m_ways; i++){
    387         if(!(m_lru_tab[set][i].recent) && !(m_dir_tab[set][i].lock)){
    388           way=i;
    389           return DirectoryEntry(m_dir_tab[set][way]);
     364        // looking for a not locked and not recently used entry
     365        for(size_t i=0; i<m_ways; i++)
     366        {
     367            if((not m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock) )
     368            {
     369                way=i;
     370                return DirectoryEntry(m_dir_tab[set][way]);
     371            }
    390372        }
    391       }
    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]);
     373
     374        // looking for a locked not recently used entry
     375        for(size_t i=0; i<m_ways; i++)
     376        {
     377            if( (not m_lru_tab[set][i].recent) && (m_dir_tab[set][i].lock))
     378            {
     379                way=i;
     380                return DirectoryEntry(m_dir_tab[set][way]);
     381            }
    396382        }
    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]);
     383
     384        // looking for a recently used entry not locked
     385        for(size_t i=0; i<m_ways; i++)
     386        {
     387            if( (m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock))
     388            {
     389                way=i;
     390                return DirectoryEntry(m_dir_tab[set][way]);
     391            }
    402392        }
    403       }
    404       way = 0;
    405       return DirectoryEntry(m_dir_tab[set][0]);
     393
     394        // select way 0 (even if entry is locked and recently used)
     395        way = 0;
     396        return DirectoryEntry(m_dir_tab[set][0]);
    406397    } // end select()
    407398
    … …  
    437428    ////////////////////////
    438429      HeapEntry()
    439       :owner(false,0
    440 #if L1_MULTI_CACHE
    441              ,0
    442 #endif
    443              )
     430      :owner(false,0)
    444431      {
    445432        next = 0;
    … …  
    449436    // Constructor
    450437    ////////////////////////
    451       HeapEntry(const HeapEntry &entry){
     438      HeapEntry(const HeapEntry &entry)
     439      {
    452440        owner.inst  = entry.owner.inst;
    453441        owner.srcid = entry.owner.srcid;
    454 #if L1_MULTI_CACHE
    455         owner.cache_id = entry.owner.cache_id;
    456 #endif       
    457442        next           = entry.next;
    458443      } // end constructor
    … …  
    461446    // The copy() function copies an existing source entry to a target
    462447    /////////////////////////////////////////////////////////////////////
    463       void copy(const HeapEntry &entry){
     448      void copy(const HeapEntry &entry)
     449      {
    464450        owner.inst     = entry.owner.inst;
    465451        owner.srcid    = entry.owner.srcid;
    466 #if L1_MULTI_CACHE
    467         owner.cache_id = entry.owner.cache_id;
    468 #endif
    469452        next           = entry.next;
    470453      } // end copy()
    … …  
    477460        << " -- owner.inst     : " << std::dec << owner.inst << std::endl
    478461        << " -- owner.srcid    : " << std::dec << owner.srcid << std::endl
    479 #if L1_MULTI_CACHE
    480         << " -- owner.cache_id : " << std::dec << owner.cache_id << std::endl
    481 #endif
    482462        << " -- next           : " << std::dec << next << std::endl;
    483463
    … …  
    640620  //                        Cache Data
    641621  ////////////////////////////////////////////////////////////////////////
    642   class CacheData {
     622  class CacheData
     623  {
    643624    private:
    644625      const uint32_t m_sets;
    … …  
    650631    public:
    651632
     633      ///////////////////////////////////////////////////////
    652634      CacheData(uint32_t ways, uint32_t sets, uint32_t words)
    653         : m_sets(sets), m_ways(ways), m_words(words) {
    654 
     635        : m_sets(sets), m_ways(ways), m_words(words)
     636      {
    655637          m_cache_data = new uint32_t ** [ways];
    656           for ( size_t i=0 ; i < ways ; i++ ) {
    657             m_cache_data[i] = new uint32_t * [sets];
     638          for ( size_t i=0 ; i < ways ; i++ )
     639          {
     640              m_cache_data[i] = new uint32_t * [sets];
    658641          }
    659           for ( size_t i=0; i<ways; i++ ) {
    660             for ( size_t j=0; j<sets; j++ ) {
    661               m_cache_data[i][j] = new uint32_t [words];
    662             }
     642          for ( size_t i=0; i<ways; i++ )
     643          {
     644              for ( size_t j=0; j<sets; j++ )
     645              {
     646                  m_cache_data[i][j] = new uint32_t [words];
     647              }
    663648          }
    664         }
    665 
    666       ~CacheData() {
    667           for(size_t i=0; i<m_ways ; i++){
    668               for(size_t j=0; j<m_sets ; j++){
     649      }
     650      ////////////
     651      ~CacheData()
     652      {
     653          for(size_t i=0; i<m_ways ; i++)
     654          {
     655              for(size_t j=0; j<m_sets ; j++)
     656              {
    669657                  delete [] m_cache_data[i][j];
    670658              }
    671659          }
    672           for(size_t i=0; i<m_ways ; i++){
     660          for(size_t i=0; i<m_ways ; i++)
     661          {
    673662              delete [] m_cache_data[i];
    674663          }
    675664          delete [] m_cache_data;
    676665      }
    677 
    678       uint32_t read (
    679           const uint32_t &way,
    680           const uint32_t &set,
    681           const uint32_t &word) const {
    682 
    683         assert((set  < m_sets ) && "Cache data error: Trying to read a wrong set" );
    684         assert((way  < m_ways ) && "Cache data error: Trying to read a wrong way" );
    685         assert((word < m_words) && "Cache data error: Trying to read a wrong word");
    686 
    687         return m_cache_data[way][set][word];
    688       }
    689 
    690       void read_line(
    691           const uint32_t &way,
    692           const uint32_t &set,
    693           sc_core::sc_signal<uint32_t> * cache_line)
    694       {
    695         assert((set < m_sets ) && "Cache data error: Trying to read a wrong set" );
    696         assert((way < m_ways ) && "Cache data error: Trying to read a wrong way" );
    697 
    698         for (uint32_t word=0; word<m_words; word++)
    699           cache_line[word].write(m_cache_data[way][set][word]);
    700       }
    701 
    702       void write (
    703           const uint32_t &way,
    704           const uint32_t &set,
    705           const uint32_t &word,
    706           const uint32_t &data,
    707           const uint32_t &be = 0xF) {
    708 
    709         assert((set  < m_sets ) && "Cache data error: Trying to write a wrong set" );
    710         assert((way  < m_ways ) && "Cache data error: Trying to write a wrong way" );
    711         assert((word < m_words) && "Cache data error: Trying to write a wrong word");
    712         assert((be  <= 0xF    ) && "Cache data error: Trying to write a wrong word cell");
    713 
    714         if (be == 0x0) return;
    715 
    716         if (be == 0xF) {
    717             m_cache_data[way][set][word] = data;
    718             return;
    719         }
    720 
    721         uint32_t mask = 0;
    722         if  (be & 0x1) mask = mask | 0x000000FF;
    723         if  (be & 0x2) mask = mask | 0x0000FF00;
    724         if  (be & 0x4) mask = mask | 0x00FF0000;
    725         if  (be & 0x8) mask = mask | 0xFF000000;
    726 
    727         m_cache_data[way][set][word] =
    728           (data & mask) | (m_cache_data[way][set][word] & ~mask);
     666      //////////////////////////////////////////
     667      uint32_t read ( const uint32_t &way,
     668                      const uint32_t &set,
     669                      const uint32_t &word) const
     670      {
     671          assert((set  < m_sets ) && "Cache data error: Trying to read a wrong set" );
     672          assert((way  < m_ways ) && "Cache data error: Trying to read a wrong way" );
     673          assert((word < m_words) && "Cache data error: Trying to read a wrong word");
     674
     675          return m_cache_data[way][set][word];
     676      }
     677      //////////////////////////////////////////
     678      void read_line( const uint32_t &way,
     679                      const uint32_t &set,
     680                      sc_core::sc_signal<uint32_t> * cache_line)
     681      {
     682          assert((set < m_sets ) && "Cache data error: Trying to read a wrong set" );
     683          assert((way < m_ways ) && "Cache data error: Trying to read a wrong way" );
     684
     685          for (uint32_t word=0; word<m_words; word++)
     686              cache_line[word].write(m_cache_data[way][set][word]);
     687      }
     688      /////////////////////////////////////////
     689      void write ( const uint32_t &way,
     690                   const uint32_t &set,
     691                   const uint32_t &word,
     692                   const uint32_t &data,
     693                   const uint32_t &be = 0xF)
     694      {
     695
     696          assert((set  < m_sets ) && "Cache data error: Trying to write a wrong set" );
     697          assert((way  < m_ways ) && "Cache data error: Trying to write a wrong way" );
     698          assert((word < m_words) && "Cache data error: Trying to write a wrong word");
     699          assert((be  <= 0xF    ) && "Cache data error: Trying to write a wrong be");
     700
     701          if (be == 0x0) return;
     702
     703          if (be == 0xF)
     704          {
     705              m_cache_data[way][set][word] = data;
     706              return;
     707          }
     708
     709          uint32_t mask = 0;
     710          if  (be & 0x1) mask = mask | 0x000000FF;
     711          if  (be & 0x2) mask = mask | 0x0000FF00;
     712          if  (be & 0x4) mask = mask | 0x00FF0000;
     713          if  (be & 0x8) mask = mask | 0xFF000000;
     714
     715          m_cache_data[way][set][word] =
     716              (data & mask) | (m_cache_data[way][set][word] & ~mask);
    729717      }
    730718  }; // end class CacheData
Note: See TracChangeset for help on using the changeset viewer.