Changeset 771 for branches/RWT/lib


Ignore:
Timestamp:
Aug 26, 2014, 4:40:29 PM (10 years ago)
Author:
meunier
Message:

RWT Branch:

  • Renamed module caba:generic_cache_tsar to caba:generic_cache_tsar_rwt
  • Renamed module caba:dspin_dhccp_param to caba:dspin_rwt_param
  • cosmetic in generic_cache.h
Location:
branches/RWT/lib/generic_cache_tsar
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/RWT/lib/generic_cache_tsar/include/generic_cache.h

    r767 r771  
    8686//////////////////////////
    8787{
    88     typedef uint32_t    data_t;
    89     typedef uint32_t    be_t;
    90 
    91     data_t              *r_data ;
    92     addr_t               *r_tag ;
    93     int                 *r_state;
    94     bool                *r_lru ;
    95 
    96     size_t              m_ways;
    97     size_t              m_sets;
    98     size_t              m_words;
    99 
    100     const soclib::common::AddressMaskingTable<addr_t>  m_x ;
    101     const soclib::common::AddressMaskingTable<addr_t>  m_y ;
    102     const soclib::common::AddressMaskingTable<addr_t>  m_z ;
     88    typedef uint32_t data_t;
     89    typedef uint32_t be_t;
     90
     91    data_t           *r_data ;
     92    addr_t           *r_tag ;
     93    int              *r_state;
     94    bool             *r_lru ;
     95
     96    size_t           m_ways;   
     97    size_t           m_sets;   
     98    size_t           m_words;
     99
     100    const soclib::common::AddressMaskingTable<addr_t> m_x ;
     101    const soclib::common::AddressMaskingTable<addr_t> m_y ;
     102    const soclib::common::AddressMaskingTable<addr_t> m_z ;
    103103
    104104    //////////////////////////////////////////////////////////////
    … …  
    134134        cache_lru(way, set) = true;
    135135
    136             for (way2 = 0; way2 < m_ways; way2++ )
     136            for (way2 = 0; way2 < m_ways; way2++)
    137137        {
    138138                if (cache_lru(way2, set) == false) return;
    139139            }
    140140            // all lines are new -> they all become old
    141             for (way2 = 0; way2 < m_ways; way2++ )
     141            for (way2 = 0; way2 < m_ways; way2++)
    142142        {
    143143                cache_lru(way2, set) = false;
    … …  
    146146
    147147    ////////////////////////////////
    148     inline data_t be2mask( be_t be )
     148    inline data_t be2mask(be_t be)
    149149    {
    150150        data_t mask = 0;
    … …  
    159159
    160160    //////////////////////////////////////////
    161     GenericCache(   const std::string  &name,
    162                     size_t              nways,
    163                     size_t              nsets,
    164                     size_t              nwords)
     161    GenericCache(const std::string &name,
     162                    size_t            nways,
     163                    size_t            nsets,
     164                    size_t            nwords)
    165165        : m_ways(nways),
    166166          m_sets(nsets),
    … …  
    186186
    187187#ifdef GENERIC_CACHE_DEBUG
    188 std::cout << "constructing " << name << std::endl
     188        std::cout << "constructing " << name << std::endl
    189189          << "- nways  = " << nways << std::endl
    190190          << "- nsets  = " << nsets << std::endl
    … …  
    196196#endif
    197197
    198         r_data    = new data_t[nways*nsets*nwords];
    199         r_tag     = new addr_t[nways*nsets];
    200         r_state   = new int[nways*nsets];
    201         r_lru     = new bool[nways*nsets];
     198        r_data  = new data_t[nways*nsets*nwords];
     199        r_tag   = new addr_t[nways*nsets];
     200        r_state = new int[nways*nsets];
     201        r_lru   = new bool[nways*nsets];
    202202    }
    203203
    … …  
    212212
    213213    ////////////////////
    214     inline void reset( )
     214    inline void reset()
    215215    {
    216216        std::memset(r_data, 0, sizeof(*r_data)*m_ways*m_sets*m_words);
    … …  
    230230    // Both data & directory are accessed.
    231231    /////////////////////////////////////////////////////////////////////
    232     inline bool read( addr_t    ad,
    233                       data_t*   dt)
    234     {
    235         const addr_t      tag  = m_z[ad];
    236         const size_t      set  = m_y[ad];
    237         const size_t      word = m_x[ad];
    238 
    239         for ( size_t way = 0; way < m_ways; way++ )
    240         {
    241             if ( (tag == cache_tag(way, set)) 
    242                    && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)) )
     232    inline bool read(addr_t  ad,
     233                     data_t* dt)
     234    {
     235        const addr_t tag  = m_z[ad];
     236        const size_t set  = m_y[ad];
     237        const size_t word = m_x[ad];
     238
     239        for (size_t way = 0; way < m_ways; way++)
     240        {
     241            if ((tag == cache_tag(way, set)) 
     242                   && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)) )
    243243            {
    244244                *dt = cache_data(way, set, word);
    … …  
    256256    // The selected way, set and word index are returned in case of hit.
    257257    /////////////////////////////////////////////////////////////////////
    258     inline bool read( addr_t    ad,
    259                       data_t*   dt,
    260                       size_t*  selway,
    261                       size_t*  selset,
    262                       size_t*  selword)
    263     {
    264         const addr_t      tag  = m_z[ad];
    265         const size_t      set  = m_y[ad];
    266         const size_t      word = m_x[ad];
    267 
    268         for ( size_t way = 0; way < m_ways; way++ )
    269         {
    270             if ( (tag == cache_tag(way, set)) and
    271                  ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)))
     258    inline bool read(addr_t ad,
     259                     data_t* dt,
     260                     size_t* selway,
     261                     size_t* selset,
     262                     size_t* selword)
     263    {
     264        const addr_t tag  = m_z[ad];
     265        const size_t set  = m_y[ad];
     266        const size_t word = m_x[ad];
     267
     268        for (size_t way = 0; way < m_ways; way++)
     269        {
     270            if ((tag == cache_tag(way, set)) and
     271                 ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)))
    272272            {
    273273                *selway  = way;
    … …  
    292292    // returned in the other arguments.
    293293    ////////////////////////////////////////////////////////////////////
    294     inline void read( addr_t    ad,
    295                       data_t*  dt,
    296                       size_t*  selway,
    297                       size_t*  selset,
    298                       size_t*  selword,
    299                       int*      state )
    300     {
    301         const addr_t      tag  = m_z[ad];
    302         const size_t      set  = m_y[ad];
    303         const size_t      word = m_x[ad];
     294    inline void read(addr_t  ad,
     295                     data_t* dt,
     296                     size_t* selway,
     297                     size_t* selset,
     298                     size_t* selword,
     299                     int*    state)
     300    {
     301        const addr_t tag  = m_z[ad];
     302        const size_t set  = m_y[ad];
     303        const size_t word = m_x[ad];
    304304
    305305        // default return values
    … …  
    310310        *dt      = 0;
    311311
    312         for ( size_t way = 0; way < m_ways; way++ )
    313         {
    314             if ( tag == cache_tag(way, set) )  // matching tag
    315             {
    316 
    317                 if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC )
     312        for (size_t way = 0; way < m_ways; way++)
     313        {
     314            if (tag == cache_tag(way, set))  // matching tag
     315            {
     316
     317                if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)
    318318                {
    319319                    *state   = CACHE_SLOT_STATE_VALID_CC;
    … …  
    324324                    cache_set_lru(way, set);
    325325                }
    326                 else if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC )
     326                else if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)
    327327                {
    328328                    *state   = CACHE_SLOT_STATE_VALID_NCC;
    … …  
    333333                    cache_set_lru(way, set);
    334334                }
    335                 else if ( cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI )
     335                else if (cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI)
    336336                {
    337337                    *state   = CACHE_SLOT_STATE_ZOMBI;
    … …  
    350350    // The selected way, set and word index are returned in case of hit.
    351351    /////////////////////////////////////////////////////////////////////
    352     inline bool read_neutral( addr_t    ad,
    353                                       data_t*   dt,
    354                                           size_t*  selway,
    355                                           size_t*  selset,
    356                                           size_t*  selword)
    357     {
    358         const addr_t      tag  = m_z[ad];
    359         const size_t      set  = m_y[ad];
    360         const size_t      word = m_x[ad];
    361 
    362         for ( size_t way = 0; way < m_ways; way++ )
    363         {
    364             if ( (tag == cache_tag(way, set)) 
    365                    && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ) )
     352    inline bool read_neutral(addr_t  ad,
     353                             data_t* dt,
     354                             size_t* selway,
     355                             size_t* selset,
     356                             size_t* selword)
     357    {
     358        const addr_t tag  = m_z[ad];
     359        const size_t set  = m_y[ad];
     360        const size_t word = m_x[ad];
     361
     362        for (size_t way = 0; way < m_ways; way++)
     363        {
     364            if ((tag == cache_tag(way, set)) 
     365                   && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ))
    366366            {
    367367                *selway  = way;
    … …  
    384384    // This function is used by the cc_vcache to get a 64 bits page table entry.
    385385    /////////////////////////////////////////////////////////////////////////////
    386     inline bool read( addr_t    ad,
    387                       data_t*   dt,
    388                       data_t*   dt_next,
    389                       size_t*   selway,
    390                       size_t*   selset,
    391                       size_t*   selword)
    392     {
    393         const addr_t      tag  = m_z[ad];
    394         const size_t      set  = m_y[ad];
    395         const size_t      word = m_x[ad];
    396 
    397         for ( size_t way = 0; way < m_ways; way++ )
    398         {
    399             if ( (tag == cache_tag(way, set))   
    400                    &&( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) )
    401             {
    402                 *dt      = cache_data(way, set, word);
    403                 if ( word+1 < m_words)
    404                 {
    405                     *dt_next = cache_data(way, set, word+1);
     386    inline bool read( addr_t  ad,
     387                      data_t* dt,
     388                      data_t* dt_next,
     389                      size_t* selway,
     390                      size_t* selset,
     391                      size_t* selword)
     392    {
     393        const addr_t tag  = m_z[ad];
     394        const size_t set  = m_y[ad];
     395        const size_t word = m_x[ad];
     396
     397        for (size_t way = 0; way < m_ways; way++)
     398        {
     399            if ((tag == cache_tag(way, set))   
     400                   &&( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)))
     401            {
     402                *dt = cache_data(way, set, word);
     403                if (word + 1 < m_words)
     404                {
     405                    *dt_next = cache_data(way, set, word + 1);
    406406                }
    407407                *selway  = way;
    … …  
    425425    // returned in the other arguments.
    426426    ////////////////////////////////////////////////////////////////////
    427     inline void read( addr_t    ad,
    428                       data_t*  dt,
    429                       data_t*  dt_next,
    430                       size_t*  selway,
    431                       size_t*  selset,
    432                       size_t*  selword,
    433                       int*      state )
    434     {
    435         const addr_t      tag  = m_z[ad];
    436         const size_t      set  = m_y[ad];
    437         const size_t      word = m_x[ad];
     427    inline void read(addr_t  ad,
     428                     data_t* dt,
     429                     data_t* dt_next,
     430                     size_t* selway,
     431                     size_t* selset,
     432                     size_t* selword,
     433                     int*    state)
     434    {
     435        const addr_t tag  = m_z[ad];
     436        const size_t set  = m_y[ad];
     437        const size_t word = m_x[ad];
    438438
    439439        // default return values
    … …  
    444444        *dt      = 0;
    445445
    446         for ( size_t way = 0; way < m_ways; way++ )
    447         {
    448             if ( tag == cache_tag(way, set) )  // matching tag
    449             {
    450 
    451                 if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC )
     446        for (size_t way = 0; way < m_ways; way++)
     447        {
     448            if (tag == cache_tag(way, set))  // matching tag
     449            {
     450
     451                if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)
    452452                {
    453453                    *state   = CACHE_SLOT_STATE_VALID_CC;
    … …  
    456456                    *selword = word;
    457457                    *dt      = cache_data(way, set, word);
    458                     if ( word+1 < m_words)
     458                    if (word + 1 < m_words)
    459459                    {
    460460                        *dt_next = cache_data(way, set, word+1);
    … …  
    463463                }
    464464
    465                 else if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC )
     465                else if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)
    466466                {
    467467                    *state   = CACHE_SLOT_STATE_VALID_NCC;
    … …  
    470470                    *selword = word;
    471471                    *dt      = cache_data(way, set, word);
    472                     if ( word+1 < m_words)
     472                    if (word + 1 < m_words)
    473473                    {
    474                         *dt_next = cache_data(way, set, word+1);
     474                        *dt_next = cache_data(way, set, word + 1);
    475475                    }
    476476                    cache_set_lru(way, set);
    477477                }
    478478
    479                 else if ( cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI )
     479                else if (cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI)
    480480                {
    481481                    *state   = CACHE_SLOT_STATE_ZOMBI;
    … …  
    496496    // while we write in the data part with a different address in the same cycle.
    497497    ///////////////////////////////////////////////////////////////////////////////
    498     inline bool hit(  addr_t    ad,
    499                       size_t*   selway,
    500                       size_t*   selset,
    501                       size_t*  selword)
    502     {
    503         const addr_t      tag  = m_z[ad];
    504         const size_t      set  = m_y[ad];
    505         const size_t      word = m_x[ad];
    506 
    507         for ( size_t way = 0; way < m_ways; way++ )
    508         {
    509             if ( (tag == cache_tag(way, set))
    510                    && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or(cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ) )
     498    inline bool hit(addr_t  ad,
     499                    size_t* selway,
     500                    size_t* selset,
     501                    size_t* selword)
     502    {
     503        const addr_t tag  = m_z[ad];
     504        const size_t set  = m_y[ad];
     505        const size_t word = m_x[ad];
     506
     507        for (size_t way = 0; way < m_ways; way++)
     508        {
     509            if ((tag == cache_tag(way, set))
     510                   && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or(cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)))
    511511            {
    512512                *selway  = way;
    … …  
    531531    // while we write in the data part with a different address in the same cycle.
    532532    ///////////////////////////////////////////////////////////////////////////////
    533     inline void read_dir(  addr_t       ad,
    534                            int*     state,
    535                            size_t*      way,
    536                            size_t*      set,
    537                            size_t* word)
    538     {
    539         const addr_t      ad_tag  = m_z[ad];
    540         const size_t      ad_set  = m_y[ad];
    541         const size_t      ad_word = m_x[ad];
    542         for ( size_t _way = 0; _way < m_ways; _way++ )
    543         {
    544             if ( (ad_tag == cache_tag(_way, ad_set) ) and
    545                  (cache_state(_way, ad_set) != CACHE_SLOT_STATE_EMPTY) )
     533    inline void read_dir(addr_t  ad,
     534                         int*    state,
     535                         size_t* way,
     536                         size_t* set,
     537                         size_t* word)
     538    {
     539        const addr_t ad_tag  = m_z[ad];
     540        const size_t ad_set  = m_y[ad];
     541        const size_t ad_word = m_x[ad];
     542        for (size_t _way = 0; _way < m_ways; _way++)
     543        {
     544            if ((ad_tag == cache_tag(_way, ad_set)) and
     545                (cache_state(_way, ad_set) != CACHE_SLOT_STATE_EMPTY))
    546546            {
    547547                *state = cache_state(_way, ad_set);
    … …  
    562562    // Returns the access status and the tag value in the state and tag argument.
    563563    ///////////////////////////////////////////////////////////////////////////////
    564     inline void read_dir(  size_t       way,
    565                            size_t       set,
    566                            addr_t*  tag,
    567                            int*     state )
     564    inline void read_dir(size_t  way,
     565                         size_t  set,
     566                         addr_t* tag,
     567                         int*    state)
    568568    {
    569569        *state = cache_state(way, set);
    … …  
    581581    // It does not use the directory and cannot miss.
    582582    //////////////////////////////////////////////////////////////////
    583     inline void write(size_t    way,
    584                       size_t    set,
    585                       size_t    word,
    586                       data_t    data)
     583    inline void write(size_t way,
     584                      size_t set,
     585                      size_t word,
     586                      data_t data)
    587587    {
    588588        cache_data(way, set, word) = data;
    … …  
    594594    // It does not use the directory and cannot miss.
    595595    ////////////////////////////////////////////////////////////////////////////
    596     inline void write(size_t    way,
    597                       size_t    set,
    598                       size_t    word,
    599                       data_t    data,
    600                       be_t          be)
     596    inline void write(size_t way,
     597                      size_t set,
     598                      size_t word,
     599                      data_t data,
     600                      be_t   be)
    601601    {
    602602        data_t mask = be2mask(be);
    … …  
    610610    // It returns true if the line was valid, and returns the line index.
    611611    //////////////////////////////////////////////////////////////////////////
    612     inline bool inval(size_t    way,
    613                       size_t    set,
    614                       addr_t*   nline)
    615     {
    616         if( (cache_state(way,set) == CACHE_SLOT_STATE_VALID_CC) or  (cache_state(way,set) == CACHE_SLOT_STATE_VALID_NCC))
     612    inline bool inval(size_t  way,
     613                      size_t  set,
     614                      addr_t* nline)
     615    {
     616        if ((cache_state(way,set) == CACHE_SLOT_STATE_VALID_CC) or  (cache_state(way,set) == CACHE_SLOT_STATE_VALID_NCC))
    617617        {
    618618            cache_state(way,set) = CACHE_SLOT_STATE_EMPTY;
    … …  
    631631    // and a Boolean indicating that a cleanup is requested.
    632632    //////////////////////////////////////////////////////////////////////////////////
    633     inline bool victim_select(addr_t    ad,
    634                               addr_t*   victim,
    635                               size_t*   way,
    636                               size_t*   set)
    637     {
    638         bool   found   = false;
    639         bool   cleanup = false;
     633    inline bool victim_select(addr_t  ad,
     634                              addr_t* victim,
     635                              size_t* way,
     636                              size_t* set)
     637    {
     638        bool found   = false;
     639        bool cleanup = false;
    640640
    641641        *set = m_y[ad];
    … …  
    643643
    644644        // Search first empty slot
    645         for ( size_t _way = 0 ; _way < m_ways && !found ; _way++ )
    646         {
    647             if( ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_CC ) and ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_NCC ))  // empty
     645        for (size_t _way = 0 ; _way < m_ways && !found ; _way++)
     646        {
     647            if ((cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_CC) and (cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_NCC ))  // empty
    648648            {
    649649                found   = true;
    … …  
    654654
    655655        // If no empty slot, search first  old slot (lru == false)
    656         if ( !found )
     656        if (!found)
    657657        {
    658             for ( size_t _way = 0 ; _way < m_ways && !found ; _way++ )
    659             {
    660                 if ( not cache_lru(_way, *set) )
     658            for (size_t _way = 0 ; _way < m_ways && !found ; _way++)
     659            {
     660                if (not cache_lru(_way, *set))
    661661                {
    662662                    found   = true;
    … …  
    668668
    669669        assert(found && "all ways can't be new at the same time");
    670         *victim = (addr_t)((cache_tag(*way,*set) * m_sets) + *set);
     670        *victim = (addr_t) ((cache_tag(*way,*set) * m_sets) + *set);
    671671        return cleanup;
    672672    }
    … …  
    681681    // and two Boolean indicating success and a required cleanup.
    682682    //////////////////////////////////////////////////////////////////////////////////
    683     inline void read_select(addr_t       ad,
    684                             addr_t*   victim,
    685                             size_t*   way,
    686                             size_t*   set,
    687                             bool*     found,
    688                             bool*     cleanup )
     683    inline void read_select(addr_t ad,
     684                            addr_t* victim,
     685                            size_t* way,
     686                            size_t* set,
     687                            bool*   found,
     688                            bool*   cleanup)
    689689    {
    690690        size_t _set = m_y[ad];
    … …  
    693693
    694694        // Search first empty slot
    695         for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ )
    696         {
    697             if ( cache_state(_way, _set) == CACHE_SLOT_STATE_EMPTY )
     695        for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++)
     696        {
     697            if (cache_state(_way, _set) == CACHE_SLOT_STATE_EMPTY)
    698698            {
    699699                *found   = true;
    … …  
    704704            }
    705705        }
    706         //////////////////////////////////////////////////////////////
    707         /*for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ )
    708         {
    709             if ( not cache_lru(_way, _set) and
    710                  (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) and
    711                  (cache_state(_way, _set) == CACHE_SLOT_STATE_VALID_NCC) )
    712             {
    713                 *found   = true;
    714                 *cleanup = true;
    715                 *way     = _way;
    716                 *set     = m_y[ad];
    717                 *victim  = (addr_t)((cache_tag(*way,_set) * m_sets) + _set);
    718                 return;
    719             }
    720         }*/
     706       
    721707        // Search first not zombi old slot
    722         for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ )
    723         {
    724             if ( not cache_lru(_way, _set) and
    725                  (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) )
     708        for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++)
     709        {
     710            if (not cache_lru(_way, _set) and
     711                 (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI))
    726712            {
    727713                *found   = true;
    … …  
    734720        }
    735721        // Search first not zombi slot
    736         for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ )
    737         {
    738             if ( cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI)
     722        for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++)
     723        {
     724            if (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI)
    739725            {
    740726                *found   = true;
    … …  
    756742    // identified by the way & set.
    757743    //////////////////////////////////////////////////////////////////
    758     inline void victim_update_tag( addr_t       ad,
    759                                    size_t       way,
    760                                    size_t       set )
     744    inline void victim_update_tag(addr_t ad,
     745                                  size_t way,
     746                                  size_t set)
    761747    {
    762748        addr_t  tag     = m_z[ad];
    … …  
    771757    // identified by the way & set, when using the ZOMBI state.
    772758    //////////////////////////////////////////////////////////////////
    773     inline void write_dir( addr_t       ad,
    774                            size_t       way,
    775                            size_t       set,
    776                            int      state)
    777     {
    778         addr_t  tag    = m_z[ad];
     759    inline void write_dir(addr_t ad,
     760                          size_t way,
     761                          size_t set,
     762                          int    state)
     763    {
     764        addr_t tag = m_z[ad];
    779765
    780766        assert( ( (state == CACHE_SLOT_STATE_VALID_CC) or
    … …  
    793779        cache_state(way, set) = state;
    794780
    795         if ( (state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC) ) cache_set_lru(way, set);
     781        if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) cache_set_lru(way, set);
    796782    }
    797783
    … …  
    801787    // It does not affect the tag
    802788    //////////////////////////////////////////////////////////////////
    803     inline void write_dir( size_t       way,
    804                            size_t       set,
    805                            int      state)
     789    inline void write_dir(size_t way,
     790                          size_t set,
     791                          int    state)
    806792    {
    807793        assert( ( (state == CACHE_SLOT_STATE_VALID_CC) or
    … …  
    827813    // Both DATA and DIRECTORY are written
    828814    ///////////////////////////////////////////////////////////////////
    829     inline void update(addr_t   ad,
    830                        size_t   way,
    831                        size_t   set,
    832                        data_t*  buf)
     815    inline void update(addr_t  ad,
     816                       size_t  way,
     817                       size_t  set,
     818                       data_t* buf)
    833819    {
    834820        addr_t tag = m_z[ad];
    … …  
    837823        cache_state(way, set) = CACHE_SLOT_STATE_VALID_CC;
    838824        cache_set_lru(way, set);
    839         for ( size_t word = 0 ; word < m_words ; word++ )
     825        for (size_t word = 0 ; word < m_words ; word++)
    840826        {
    841827            cache_data(way, set, word) = buf[word] ;
    … …  
    846832    void fileTrace(FILE* file)
    847833    {
    848         for( size_t nway = 0 ; nway < m_ways ; nway++)
    849         {
    850             for( size_t nset = 0 ; nset < m_sets ; nset++)
     834        for (size_t nway = 0 ; nway < m_ways ; nway++)
     835        {
     836            for (size_t nset = 0 ; nset < m_sets ; nset++)
    851837            {
    852838                fprintf(file, "%d / ", (int)cache_state(nway, nset));
    … …  
    854840                fprintf(file, "set %d / ", (int)nset);
    855841                fprintf(file, "@ = %08zX / ",
    856                         ((cache_tag(nway, nset)*m_sets+nset)*m_words*4));
    857                 for( size_t nword = m_words ; nword > 0 ; nword--)
    858                 {
    859                     unsigned int data = cache_data(nway, nset, nword-1);
    860                     fprintf(file, "%08X ", data );
     842                        ((cache_tag(nway, nset) * m_sets + nset) * m_words * 4));
     843                for (size_t nword = m_words ; nword > 0 ; nword--)
     844                {
     845                    unsigned int data = cache_data(nway, nset, nword - 1);
     846                    fprintf(file, "%08X ", data);
    861847                }
    862848                fprintf(file, "\n");
    … …  
    868854    inline void printTrace()
    869855    {
    870         for ( size_t way = 0; way < m_ways ; way++ )
    871         {
    872             for ( size_t set = 0 ; set < m_sets ; set++ )
     856        for (size_t way = 0; way < m_ways ; way++)
     857        {
     858            for (size_t set = 0 ; set < m_sets ; set++)
    873859            {
    874860                addr_t addr = (((addr_t)cache_tag(way,set))*m_words*m_sets+m_words*set)*4;
    … …  
    878864                          << std::hex << " | @ " << addr;
    879865
    880                 for ( size_t word = 0 ; word < m_words ; word++ )
     866                for (size_t word = 0 ; word < m_words ; word++)
    881867                {
    882868                    std::cout << " | " << cache_data(way,set,word) ;
    … …  
    886872        }
    887873    }
    888 
    889     ///////////////////////////////////////////////////////////////////////////
    890     // This function is deprecated as it is difficult to implement in 1 cycle.
    891     ///////////////////////////////////////////////////////////////////////////
    892     __attribute__((deprecated))
    893     inline bool inval(addr_t    ad)
    894     {
    895         bool              hit = false;
    896         const addr_t      tag = m_z[ad];
    897         const size_t      set = m_y[ad];
    898 
    899         for ( size_t way = 0 ; way < m_ways && !hit ; way++ )
    900         {
    901             if ( (tag == cache_tag(way, set)) and
    902                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    903             {
    904                 hit                   = true;
    905                 cache_state(way, set) = CACHE_SLOT_STATE_EMPTY;
    906                 cache_lru(way, set)   = false;
    907             }
    908         }
    909         return hit;
    910     }
    911 
    912     ////////////////////////////////////////////////////////////////////////////////
    913     // This function is deprecated as it is difficult to implement in 1 cycle.
    914     ////////////////////////////////////////////////////////////////////////////////
    915     __attribute__((deprecated))
    916     inline bool inval( addr_t   ad,
    917                        size_t*  selway,
    918                        size_t*  selset )
    919     {
    920         bool            hit = false;
    921         const addr_t    tag = m_z[ad];
    922         const size_t    set = m_y[ad];
    923 
    924         for ( size_t way = 0 ; way < m_ways && !hit ; way++ )
    925         {
    926             if ( (tag == cache_tag(way, set)) and
    927                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    928             {
    929                 hit                   = true;
    930                 cache_state(way, set) = CACHE_SLOT_STATE_EMPTY;
    931                 cache_lru(way, set)   = false;
    932                 *selway             = way;
    933                 *selset             = set;
    934             }
    935         }
    936         return hit;
    937     }
    938 
    939     ////////////////////////////////////////////////////////////////////////////////
    940     // This function is deprecated as the directory must be a dual port RAM...
    941     ////////////////////////////////////////////////////////////////////////////////
    942     __attribute__((deprecated))
    943     inline bool update( addr_t  ad,
    944                         data_t* buf,
    945                         addr_t* victim )
    946     {
    947         size_t set, way;
    948         bool   cleanup = victim_select(ad, victim, &way, &set);
    949         victim_update_tag (ad, way, set);
    950 
    951         for ( size_t word = 0 ; word < m_words ; word++ ) {
    952             cache_data(way, set, word) = buf[word] ;
    953         }
    954 
    955         return cleanup;
    956     }
    957 
    958     ////////////////////////////////////////////////////////////////////////////
    959     // this function is deprecated, as it is difficult to implement in 1 cycle.
    960     ////////////////////////////////////////////////////////////////////////////
    961     __attribute__((deprecated))
    962     inline bool write(addr_t    ad,
    963                       data_t    dt)
    964     {
    965         const addr_t      tag  = m_z[ad];
    966         const size_t      set  = m_y[ad];
    967         const size_t      word = m_x[ad];
    968 
    969         for ( size_t way = 0; way < m_ways; way++ )
    970         {
    971             if ( (tag == cache_tag(way, set)) and
    972                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    973             {
    974                 cache_data(way, set, word) = dt;
    975                 cache_set_lru(way, set);
    976                 return true;
    977             }
    978         }
    979         return false;
    980     }
    981 
    982     ////////////////////////////////////////////////////////////////////////////
    983     // this function is deprecated, as it is difficult to implement in 1 cycle.
    984     ////////////////////////////////////////////////////////////////////////////
    985     __attribute__((deprecated))
    986     inline bool write(addr_t    ad,
    987                       data_t    dt,
    988                       be_t      be)
    989     {
    990         const addr_t      tag  = m_z[ad];
    991         const size_t      set  = m_y[ad];
    992         const size_t      word = m_x[ad];
    993 
    994         for ( size_t way = 0; way < m_ways; way++ )
    995         {
    996             if ( (tag == cache_tag(way, set)) and
    997                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    998             {
    999                 data_t mask = be2mask(be);
    1000                 data_t prev = cache_data(way, set, word);
    1001                 cache_data(way, set, word) = (mask & dt) | (~mask & prev);
    1002                 cache_set_lru(way, set);
    1003                 return true;
    1004             }
    1005         }
    1006         return false;
    1007     }
    1008    
    1009     /////////////////////////////////////////////////////////////////////////////
    1010     // this function is deprecated, as it is difficult to implement in 1 cycle.
    1011     /////////////////////////////////////////////////////////////////////////////
    1012     __attribute__((deprecated))
    1013     inline bool write(addr_t    ad,
    1014                       data_t    dt,
    1015                       size_t*   nway)
    1016     {
    1017         const addr_t      tag  = m_z[ad];
    1018         const size_t      set  = m_y[ad];
    1019         const size_t      word = m_x[ad];
    1020 
    1021         for ( size_t way = 0; way < m_ways; way++ )
    1022         {
    1023             if ( (tag == cache_tag(way, set)) and
    1024                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    1025             {
    1026                 cache_data(way, set, word) = dt;
    1027                 cache_set_lru(way, set);
    1028                 *nway = way;
    1029                 return true;
    1030             }
    1031         }
    1032         return false;
    1033     }
    1034 
    1035     /////////////////////////////////////////////////////////////////////////////
    1036     // this function is deprecated, as it is difficult to implement in 1 cycle.
    1037     /////////////////////////////////////////////////////////////////////////////
    1038     __attribute__((deprecated))
    1039     inline bool write(addr_t    ad,
    1040                       data_t    dt,
    1041                       size_t*   nway,
    1042                       be_t      be)
    1043     {
    1044         const addr_t      tag  = m_z[ad];
    1045         const size_t      set  = m_y[ad];
    1046         const size_t      word = m_x[ad];
    1047 
    1048         for ( size_t way = 0; way < m_ways; way++ )
    1049         {
    1050             if ( (tag == cache_tag(way, set)) and
    1051                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    1052             {
    1053                 data_t mask = be2mask(be);
    1054                 data_t prev = cache_data(way, set, word);
    1055                 cache_data(way, set, word) = (mask & dt) | (~mask & prev);
    1056                 cache_set_lru(way, set);
    1057                 *nway = way;
    1058                 return true;
    1059             }
    1060         }
    1061         return false;
    1062     }
    1063    
     874   
    1064875};
    1065876

  • branches/RWT/lib/generic_cache_tsar/metadata/generic_cache.sd

    r297 r771  
    44__version__ = "$Revision: 917 $"
    55
    6 Module('caba:generic_cache_tsar',
    7         classname = 'soclib::GenericCache',
    8         header_files = ['../include/generic_cache.h',],
    9            tmpl_parameters = [
    10         parameter.Type('addr_t'),
    11         ],
    12         uses = [Uses('common:mapping_table'),
    13                         Uses('common:address_masking_table',
    14                                  data_t = parameter.Reference('addr_t')),],
     6Module('caba:generic_cache_tsar_rwt',
     7    classname = 'soclib::GenericCache',
     8    header_files = ['../include/generic_cache.h',],
     9    tmpl_parameters = [
     10        parameter.Type('addr_t'),
     11    ],
     12    uses = [
     13         Uses('common:mapping_table'),
     14         Uses('common:address_masking_table',
     15              data_t = parameter.Reference('addr_t')),
     16    ],
    1517)
Note: See TracChangeset for help on using the changeset viewer.