Ignore:
Timestamp:
May 28, 2013, 9:35:16 AM (11 years ago)
Author:
alain
Message:

Introducing support for addresses larger than 32 bits.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/generic_cache_tsar/include/generic_cache.h

    r365 r393  
    3434// This object is a generic, set associative, cache.
    3535// Each slot can be in three states: VALID, EMPTY or ZOMBI.
    36 // The ZOMBI state is used by cache coherence protocoles to indicate
     36// The ZOMBI state is used by cache coherence protocols to indicate
    3737// a pending cleanup request.
    3838// Hit if ( (matching tag) and (state == VALID).
     
    5959// Template parameter is :
    6060// - addr_t : address format to access the cache
    61 // The address can be larger than 32 bits, but the TAG field
    62 // cannot be larger than 32 bits.
    6361/////////////////////////////////////////////////////////////////////////////////
    6462
     
    8886{
    8987    typedef uint32_t    data_t;
    90     typedef uint32_t    tag_t;
    9188    typedef uint32_t    be_t;
    9289
    9390    data_t              *r_data ;
    94     tag_t               *r_tag ;
     91    addr_t               *r_tag ;
    9592    int                 *r_state;
    9693    bool                *r_lru ;
     
    111108
    112109    //////////////////////////////////////////////
    113     inline tag_t &cache_tag(size_t way, size_t set)
     110    inline addr_t &cache_tag(size_t way, size_t set)
    114111    {
    115112        return r_tag[(way*m_sets)+set];
     
    146143    }
    147144
    148     /////////////////////////////////////////////
     145    ////////////////////////////////
    149146    inline data_t be2mask( be_t be )
    150147    {
     
    159156public:
    160157
    161     //////////////////////////////////////////////
     158    //////////////////////////////////////////
    162159    GenericCache(   const std::string   &name,
    163160                    size_t              nways,
     
    187184
    188185#ifdef GENERIC_CACHE_DEBUG
    189         std::cout
    190             << " m_x: " << m_x
    191             << " m_y: " << m_y
    192             << " m_z: " << m_z
    193             << std::endl;
     186std::cout << "constructing " << name << std::endl
     187          << "- nways  = " << nways << std::endl
     188          << "- nsets  = " << nsets << std::endl
     189          << "- nwords = " << nwords << std::endl
     190          << " m_x: " << m_x
     191          << " m_y: " << m_y
     192          << " m_z: " << m_z
     193          << std::endl;
    194194#endif
    195195
    196196        r_data    = new data_t[nways*nsets*nwords];
    197         r_tag     = new tag_t[nways*nsets];
     197        r_tag     = new addr_t[nways*nsets];
    198198        r_state   = new int[nways*nsets];
    199199        r_lru     = new bool[nways*nsets];
     
    226226                      data_t*   dt)
    227227    {
    228         const tag_t       tag  = m_z[ad];
     228        const addr_t      tag  = m_z[ad];
    229229        const size_t      set  = m_y[ad];
    230230        const size_t      word = m_x[ad];
     
    255255                      size_t*   selword)
    256256    {
    257         const tag_t       tag  = m_z[ad];
     257        const addr_t      tag  = m_z[ad];
    258258        const size_t      set  = m_y[ad];
    259259        const size_t      word = m_x[ad];
     
    292292                      int*      state )
    293293    {
    294         const tag_t       tag  = m_z[ad];
     294        const addr_t      tag  = m_z[ad];
    295295        const size_t      set  = m_y[ad];
    296296        const size_t      word = m_x[ad];
     
    340340                                          size_t*   selword)
    341341    {
    342         const tag_t       tag  = m_z[ad];
     342        const addr_t      tag  = m_z[ad];
    343343        const size_t      set  = m_y[ad];
    344344        const size_t      word = m_x[ad];
     
    375375                      size_t*   selword)
    376376    {
    377         const tag_t       tag  = m_z[ad];
     377        const addr_t      tag  = m_z[ad];
    378378        const size_t      set  = m_y[ad];
    379379        const size_t      word = m_x[ad];
     
    417417                      int*      state )
    418418    {
    419         const tag_t       tag  = m_z[ad];
     419        const addr_t      tag  = m_z[ad];
    420420        const size_t      set  = m_y[ad];
    421421        const size_t      word = m_x[ad];
     
    470470                      size_t*   selword)
    471471    {
    472         const tag_t       tag  = m_z[ad];
     472        const addr_t      tag  = m_z[ad];
    473473        const size_t      set  = m_y[ad];
    474474        const size_t      word = m_x[ad];
     
    490490 
    491491    ///////////////////////////////////////////////////////////////////////////////
    492     // Checks the cache state for a given address, wehn the ZOMBI state is used.
     492    // Checks the cache state for a given address, when the ZOMBI state is used.
    493493    // Only the directory is accessed.
    494494    // Returns the access status in the state argument:
     
    506506                           size_t*  word)
    507507    {
    508         const tag_t       ad_tag  = m_z[ad];
     508        const addr_t      ad_tag  = m_z[ad];
    509509        const size_t      ad_set  = m_y[ad];
    510510        const size_t      ad_word = m_x[ad];
     
    534534    inline void read_dir(  size_t       way,
    535535                           size_t       set,
    536                            tag_t*   tag,
     536                           addr_t*   tag,
    537537                           int*     state )
    538538    {
     
    542542
    543543    ////////////////////////////////////////////
    544     inline tag_t get_tag(size_t way, size_t set)
     544    inline addr_t get_tag(size_t way, size_t set)
    545545    {
    546546        return cache_tag(way, set);
     
    684684                *way     = _way;
    685685                *set     = m_y[ad];
    686                 *victim  = (addr_t)((cache_tag(*way,_set) * m_sets) + _set);
     686                *victim  = cache_tag(*way,_set) * m_sets + _set;
    687687                return;
    688688            }
     
    697697                *way    = _way;
    698698                *set     = m_y[ad];
    699                 *victim  = (addr_t)((cache_tag(*way,_set) * m_sets) + _set);
     699                *victim  = cache_tag(*way,_set) * m_sets + _set;
    700700                return;
    701701            }
     
    715715                                   size_t       set )
    716716    {
    717         tag_t  tag     = m_z[ad];
     717        addr_t  tag     = m_z[ad];
    718718
    719719        cache_tag(way, set)   = tag;
     
    731731                           int      state)
    732732    {
    733         tag_t  tag     = m_z[ad];
     733        addr_t  tag     = m_z[ad];
    734734
    735735        assert( ( (state == CACHE_SLOT_STATE_VALID) or
     
    751751
    752752    //////////////////////////////////////////////////////////////////
    753     // This function write the directory part of a slot
     753    // This function change the state of a slot
    754754    // identified by the way & set, when using the ZOMBI state.
    755     // Does not affect the tag
     755    // It does not affect the tag
    756756    //////////////////////////////////////////////////////////////////
    757757    inline void write_dir( size_t       way,
     
    785785                       data_t*  buf)
    786786    {
    787         tag_t tag = m_z[ad];
     787        addr_t tag = m_z[ad];
    788788
    789789        cache_tag(way, set)   = tag;
     
    825825            for ( size_t set = 0 ; set < m_sets ; set++ )
    826826            {
    827                 std::cout << std::dec << cache_state(way, set) << " | " ;
    828                 std::cout << "way " << way << " | " ;
    829                 std::cout << "set " << set << std::hex << " | " ;
    830                 std::cout << "@ " << (cache_tag(way,set)*m_words*m_sets+m_words*set)*4 ;
     827                addr_t addr = (((addr_t)cache_tag(way,set))*m_words*m_sets+m_words*set)*4;
     828                std::cout << std::dec << cache_state(way, set)
     829                          << " | way " << way
     830                          << " | set " << set
     831                          << std::hex << " | @ " << addr;
     832
    831833                for ( size_t word = 0 ; word < m_words ; word++ )
    832834                {
     
    845847    {
    846848        bool              hit = false;
    847         const tag_t       tag = m_z[ad];
     849        const addr_t      tag = m_z[ad];
    848850        const size_t      set = m_y[ad];
    849851
     
    869871                       size_t*  selset )
    870872    {
    871         bool            hit = false;
    872         const tag_t     tag = m_z[ad];
     873        bool            hit = false;
     874        const addr_t    tag = m_z[ad];
    873875        const size_t    set = m_y[ad];
    874876
     
    914916                      data_t    dt)
    915917    {
    916         const tag_t       tag  = m_z[ad];
     918        const addr_t      tag  = m_z[ad];
    917919        const size_t      set  = m_y[ad];
    918920        const size_t      word = m_x[ad];
     
    939941                      be_t      be)
    940942    {
    941         tag_t       tag  = m_z[ad];
     943        const addr_t      tag  = m_z[ad];
    942944        const size_t      set  = m_y[ad];
    943945        const size_t      word = m_x[ad];
     
    966968                      size_t*   nway)
    967969    {
    968         const tag_t       tag  = m_z[ad];
     970        const addr_t      tag  = m_z[ad];
    969971        const size_t      set  = m_y[ad];
    970972        const size_t      word = m_x[ad];
     
    993995                      be_t      be)
    994996    {
    995         const tag_t       tag  = m_z[ad];
     997        const addr_t      tag  = m_z[ad];
    996998        const size_t      set  = m_y[ad];
    997999        const size_t      word = m_x[ad];
Note: See TracChangeset for help on using the changeset viewer.