Changeset 814


Ignore:
Timestamp:
Sep 24, 2014, 3:48:50 PM (8 years ago)
Author:
devigne
Message:

RWT commit : Cosmetic (Remove trailing whitespace)

Location:
branches/RWT
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/lib/generic_cache_tsar/include/generic_cache.h

    r771 r814  
    3838// Hit if ( (matching tag) and (state == VALID).
    3939// The replacement policy is pseudo-LRU. The victim selection process cannot
    40 // fail if the ZOMBI state is not used. 
     40// fail if the ZOMBI state is not used.
    4141// But it can fail if all ways are in ZOMBI state.
    4242/////////////////////////////////////////////////////////////////////////////////
     
    4949// Constructor parameters are :
    5050// - std::string    &name
    51 // - size_t         nways   : number of associativity levels 
     51// - size_t         nways   : number of associativity levels
    5252// - size_t         nsets   : number of sets
    5353// - size_t         nwords  : number of words in a cache line
     
    5858/////////////////////////////////////////////////////////////////////////////////
    5959// Template parameter is :
    60 // - addr_t : address format to access the cache 
     60// - addr_t : address format to access the cache
    6161/////////////////////////////////////////////////////////////////////////////////
    6262
     
    7171#include <cstring>
    7272
    73 namespace soclib { 
     73namespace soclib {
    7474
    7575enum cache_slot_state_e
     
    8383//////////////////////////
    8484template<typename addr_t>
    85 class GenericCache 
     85class GenericCache
    8686//////////////////////////
    8787{
     
    9494    bool             *r_lru ;
    9595
    96     size_t           m_ways;   
    97     size_t           m_sets;   
     96    size_t           m_ways;
     97    size_t           m_sets;
    9898    size_t           m_words;
    9999
     
    119119        return r_lru[(way*m_sets)+set];
    120120    }
    121    
     121
    122122    //////////////////////////////////////////////
    123123    inline int &cache_state(size_t way, size_t set)
     
    126126    }
    127127
    128    
     128
    129129    /////////////////////////////////////////////////
    130130    inline void cache_set_lru(size_t way, size_t set)
    131131    {
    132             size_t way2;
     132        size_t way2;
    133133
    134134        cache_lru(way, set) = true;
    135135
    136             for (way2 = 0; way2 < m_ways; way2++)
    137         {
    138                 if (cache_lru(way2, set) == false) return;
    139             }
    140             // all lines are new -> they all become old
    141             for (way2 = 0; way2 < m_ways; way2++)
    142         {
    143                 cache_lru(way2, set) = false;
    144             }
     136        for (way2 = 0; way2 < m_ways; way2++)
     137        {
     138            if (cache_lru(way2, set) == false) return;
     139        }
     140        // all lines are new -> they all become old
     141        for (way2 = 0; way2 < m_ways; way2++)
     142        {
     143            cache_lru(way2, set) = false;
     144        }
    145145    }
    146146
     
    160160    //////////////////////////////////////////
    161161    GenericCache(const std::string &name,
    162                     size_t            nways, 
    163                     size_t            nsets, 
     162                    size_t            nways,
     163                    size_t            nsets,
    164164                    size_t            nwords)
    165165        : m_ways(nways),
     
    190190          << "- nsets  = " << nsets << std::endl
    191191          << "- nwords = " << nwords << std::endl
    192           << " m_x: " << m_x 
     192          << " m_x: " << m_x
    193193          << " m_y: " << m_y
    194194          << " m_z: " << m_z
     
    224224        return cache_state(way,set);
    225225    }
    226    
     226
    227227    /////////////////////////////////////////////////////////////////////
    228228    // Read a single 32 bits word.
    229     // returns true if (matching tag) and (state == VALID) 
    230     // Both data & directory are accessed. 
     229    // returns true if (matching tag) and (state == VALID)
     230    // Both data & directory are accessed.
    231231    /////////////////////////////////////////////////////////////////////
    232     inline bool read(addr_t  ad, 
     232    inline bool read(addr_t  ad,
    233233                     data_t* dt)
    234234    {
     
    237237        const size_t word = m_x[ad];
    238238
    239         for (size_t way = 0; way < m_ways; way++) 
    240         {
    241             if ((tag == cache_tag(way, set)) 
     239        for (size_t way = 0; way < m_ways; way++)
     240        {
     241            if ((tag == cache_tag(way, set))
    242242                   && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)) )
    243243            {
     
    252252    ////////////////////////////////////////////////////////////////////
    253253    // Read a single 32 bits word.
    254     // returns true if (matching tag) and (state == VALID) 
    255     // Both data & directory are accessed. 
     254    // returns true if (matching tag) and (state == VALID)
     255    // Both data & directory are accessed.
    256256    // The selected way, set and word index are returned in case of hit.
    257257    /////////////////////////////////////////////////////////////////////
    258     inline bool read(addr_t ad, 
     258    inline bool read(addr_t ad,
    259259                     data_t* dt,
    260260                     size_t* selway,
    261261                     size_t* selset,
    262                      size_t* selword) 
     262                     size_t* selword)
    263263    {
    264264        const addr_t tag  = m_z[ad];
     
    266266        const size_t word = m_x[ad];
    267267
    268         for (size_t way = 0; way < m_ways; way++) 
     268        for (size_t way = 0; way < m_ways; way++)
    269269        {
    270270            if ((tag == cache_tag(way, set)) and
     
    286286    // Both data and directory are accessed.
    287287    // returns the access status in the state argument:
    288     // - VALID : (matching tag) and (state == VALID) 
    289     // - ZOMBI : (matching tag) and (state == ZOMBI) 
     288    // - VALID : (matching tag) and (state == VALID)
     289    // - ZOMBI : (matching tag) and (state == ZOMBI)
    290290    // - MISS  : no matching tag or EMPTY state
    291     // If VALID or ZOMBI, the data, the way, set and word index are 
     291    // If VALID or ZOMBI, the data, the way, set and word index are
    292292    // returned in the other arguments.
    293293    ////////////////////////////////////////////////////////////////////
     
    297297                     size_t* selset,
    298298                     size_t* selword,
    299                      int*    state) 
     299                     int*    state)
    300300    {
    301301        const addr_t tag  = m_z[ad];
     
    303303        const size_t word = m_x[ad];
    304304
    305         // default return values 
     305        // default return values
    306306        *state   = CACHE_SLOT_STATE_EMPTY;
    307307        *selway  = 0;
     
    310310        *dt      = 0;
    311311
    312         for (size_t way = 0; way < m_ways; way++) 
     312        for (size_t way = 0; way < m_ways; way++)
    313313        {
    314314            if (tag == cache_tag(way, set))  // matching tag
     
    343343        }
    344344    }
    345              
     345
    346346    ////////////////////////////////////////////////////////////////////
    347347    // Read a single 32 bits word, without LRU update.
    348     // returns true if (matching tag) and (state == VALID) 
    349     // Both data & directory are accessed. 
     348    // returns true if (matching tag) and (state == VALID)
     349    // Both data & directory are accessed.
    350350    // The selected way, set and word index are returned in case of hit.
    351351    /////////////////////////////////////////////////////////////////////
    352     inline bool read_neutral(addr_t  ad, 
     352    inline bool read_neutral(addr_t  ad,
    353353                             data_t* dt,
    354354                             size_t* selway,
    355355                             size_t* selset,
    356                              size_t* selword) 
     356                             size_t* selword)
    357357    {
    358358        const addr_t tag  = m_z[ad];
     
    360360        const size_t word = m_x[ad];
    361361
    362         for (size_t way = 0; way < m_ways; way++) 
    363         {
    364             if ((tag == cache_tag(way, set)) 
     362        for (size_t way = 0; way < m_ways; way++)
     363        {
     364            if ((tag == cache_tag(way, set))
    365365                   && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ))
    366366            {
     
    377377    /////////////////////////////////////////////////////////////////////////////
    378378    // Read one or two 32 bits word.
    379     // Both data & directory are accessed. 
    380     // Hit if (matching tag) and (valid == true) and (zombi == false) 
     379    // Both data & directory are accessed.
     380    // Hit if (matching tag) and (valid == true) and (zombi == false)
    381381    // If the addressed word is not the last in the cache line,
    382382    // two successive words are returned.
     
    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, 
     386    inline bool read( addr_t  ad,
     387                      data_t* dt,
    388388                      data_t* dt_next,
    389389                      size_t* selway,
     
    395395        const size_t word = m_x[ad];
    396396
    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))) 
     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)))
    401401            {
    402402                *dt = cache_data(way, set, word);
    403                 if (word + 1 < m_words) 
     403                if (word + 1 < m_words)
    404404                {
    405405                    *dt_next = cache_data(way, set, word + 1);
     
    419419    // Both data and directory are accessed.
    420420    // returns the access status in the state argument:
    421     // - VALID : (matching tag) and (state == VALID) 
    422     // - ZOMBI : (matching tag) and (state == ZOMBI) 
     421    // - VALID : (matching tag) and (state == VALID)
     422    // - ZOMBI : (matching tag) and (state == ZOMBI)
    423423    // - MISS  : no matching tag or EMPTY state
    424     // If VALID or ZOMBI, the data, the way, set and word index are 
     424    // If VALID or ZOMBI, the data, the way, set and word index are
    425425    // returned in the other arguments.
    426426    ////////////////////////////////////////////////////////////////////
     
    431431                     size_t* selset,
    432432                     size_t* selword,
    433                      int*    state) 
     433                     int*    state)
    434434    {
    435435        const addr_t tag  = m_z[ad];
     
    437437        const size_t word = m_x[ad];
    438438
    439         // default return values 
     439        // default return values
    440440        *state   = CACHE_SLOT_STATE_EMPTY;
    441441        *selway  = 0;
     
    444444        *dt      = 0;
    445445
    446         for (size_t way = 0; way < m_ways; way++) 
     446        for (size_t way = 0; way < m_ways; way++)
    447447        {
    448448            if (tag == cache_tag(way, set))  // matching tag
     
    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);
     
    470470                    *selword = word;
    471471                    *dt      = cache_data(way, set, word);
    472                     if (word + 1 < m_words) 
     472                    if (word + 1 < m_words)
    473473                    {
    474474                        *dt_next = cache_data(way, set, word + 1);
     
    490490    ///////////////////////////////////////////////////////////////////////////////
    491491    // Checks the cache state for a given address.
    492     // Only the directory is accessed. 
    493     // returns true if (matching tag) and (state == VALID) 
     492    // Only the directory is accessed.
     493    // returns true if (matching tag) and (state == VALID)
    494494    // The selected way, set and first word index are returned in case of hit.
    495495    // This function can be used when we need to access the directory
    496496    // while we write in the data part with a different address in the same cycle.
    497497    ///////////////////////////////////////////////////////////////////////////////
    498     inline bool hit(addr_t  ad, 
     498    inline bool hit(addr_t  ad,
    499499                    size_t* selway,
    500500                    size_t* selset,
     
    505505        const size_t word = m_x[ad];
    506506
    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))) 
     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;
     
    519519        return false;
    520520    }
    521  
     521
    522522    ///////////////////////////////////////////////////////////////////////////////
    523523    // Checks the cache state for a given address, when the ZOMBI state is used.
    524     // Only the directory is accessed. 
     524    // Only the directory is accessed.
    525525    // Returns the access status in the state argument:
    526     // - VALID if (matching tag) and (state == VALID) 
    527     // - ZOMBI if (matching tag) and (state == ZOMBI) 
     526    // - VALID if (matching tag) and (state == VALID)
     527    // - ZOMBI if (matching tag) and (state == ZOMBI)
    528528    // - EMPTY if no match or (state == EMPTY)
    529529    // The selected way, set and first word index are returned if not empty.
     
    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, 
     533    inline void read_dir(addr_t  ad,
    534534                         int*    state,
    535535                         size_t* way,
     
    540540        const size_t ad_set  = m_y[ad];
    541541        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)) 
     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);
     
    552552            }
    553553        }
    554        
     554
    555555        // return value if not (VALID or ZOMBI)
    556556        *state = CACHE_SLOT_STATE_EMPTY;
     
    559559    ///////////////////////////////////////////////////////////////////////////////
    560560    // Checks the cache state for a slot (set,way), when the ZOMBI state is used.
    561     // Only the directory is accessed. 
     561    // Only the directory is accessed.
    562562    // Returns the access status and the tag value in the state and tag argument.
    563563    ///////////////////////////////////////////////////////////////////////////////
     
    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, 
     583    inline void write(size_t way,
     584                      size_t set,
     585                      size_t word,
    586586                      data_t data)
    587587    {
     
    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, 
     596    inline void write(size_t way,
     597                      size_t set,
     598                      size_t word,
     599                      data_t data,
    600600                      be_t   be)
    601601    {
     
    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, 
     612    inline bool inval(size_t  way,
     613                      size_t  set,
    614614                      addr_t* nline)
    615615    {
     
    626626    // This function selects a victim slot in an associative set.
    627627    // It cannot fail, as a slot in ZOMBI state is considered EMPTY.
    628     // - we search first an EMPTY slot 
     628    // - we search first an EMPTY slot
    629629    // - if no EMPTY slot, we search an OLD slot, using lru
    630     // It returns the line index (Z + Y fields), the selected slot way and set, 
     630    // It returns the line index (Z + Y fields), the selected slot way and set,
    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, 
     633    inline bool victim_select(addr_t  ad,
     634                              addr_t* victim,
     635                              size_t* way,
    636636                              size_t* set)
    637637    {
     
    642642        *way = 0;
    643643
    644         // Search first empty slot 
     644        // Search first empty slot
    645645        for (size_t _way = 0 ; _way < m_ways && !found ; _way++)
    646646        {
     
    653653        }
    654654
    655         // If no empty slot, search first  old slot (lru == false) 
     655        // If no empty slot, search first  old slot (lru == false)
    656656        if (!found)
    657         { 
     657        {
    658658            for (size_t _way = 0 ; _way < m_ways && !found ; _way++)
    659659            {
     
    678678    // - if no empty slot, we search an OLD slot not in ZOMBI state,
    679679    // - if not found, we take the first not ZOMBI slot.
    680     // It returns the line index (Z + Y fields), the selected slot way and set, 
     680    // It returns the line index (Z + Y fields), the selected slot way and set,
    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, 
     683    inline void read_select(addr_t  ad,
     684                            addr_t* victim,
     685                            size_t* way,
    686686                            size_t* set,
    687687                            bool*   found,
     
    692692        *found = false;
    693693
    694         // Search first empty slot 
     694        // Search first empty slot
    695695        for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++)
    696696        {
     
    704704            }
    705705        }
    706        
    707         // Search first not zombi old slot 
     706
     707        // Search first not zombi old slot
    708708        for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++)
    709709        {
    710             if (not cache_lru(_way, _set) and 
     710            if (not cache_lru(_way, _set) and
    711711                 (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI))
    712712            {
     
    722722        for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++)
    723723        {
    724             if (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) 
     724            if (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI)
    725725            {
    726726                *found   = true;
     
    742742    // identified by the way & set.
    743743    //////////////////////////////////////////////////////////////////
    744     inline void victim_update_tag(addr_t ad, 
    745                                   size_t way, 
     744    inline void victim_update_tag(addr_t ad,
     745                                  size_t way,
    746746                                  size_t set)
    747747    {
     
    757757    // identified by the way & set, when using the ZOMBI state.
    758758    //////////////////////////////////////////////////////////////////
    759     inline void write_dir(addr_t ad, 
    760                           size_t way, 
     759    inline void write_dir(addr_t ad,
     760                          size_t way,
    761761                          size_t set,
    762762                          int    state)
     
    787787    // It does not affect the tag
    788788    //////////////////////////////////////////////////////////////////
    789     inline void write_dir(size_t way, 
     789    inline void write_dir(size_t way,
    790790                          size_t set,
    791791                          int    state)
     
    813813    // Both DATA and DIRECTORY are written
    814814    ///////////////////////////////////////////////////////////////////
    815     inline void update(addr_t  ad, 
    816                        size_t  way, 
    817                        size_t  set, 
     815    inline void update(addr_t  ad,
     816                       size_t  way,
     817                       size_t  set,
    818818                       data_t* buf)
    819819    {
     
    823823        cache_state(way, set) = CACHE_SLOT_STATE_VALID_CC;
    824824        cache_set_lru(way, set);
    825         for (size_t word = 0 ; word < m_words ; word++) 
     825        for (size_t word = 0 ; word < m_words ; word++)
    826826        {
    827827            cache_data(way, set, word) = buf[word] ;
     
    832832    void fileTrace(FILE* file)
    833833    {
    834         for (size_t nway = 0 ; nway < m_ways ; nway++) 
    835         {
    836             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++)
    837837            {
    838838                fprintf(file, "%d / ", (int)cache_state(nway, nset));
    839839                fprintf(file, "way %d / ", (int)nway);
    840840                fprintf(file, "set %d / ", (int)nset);
    841                 fprintf(file, "@ = %08zX / ", 
     841                fprintf(file, "@ = %08zX / ",
    842842                        ((cache_tag(nway, nset) * m_sets + nset) * m_words * 4));
    843                 for (size_t nword = m_words ; nword > 0 ; nword--) 
     843                for (size_t nword = m_words ; nword > 0 ; nword--)
    844844                {
    845845                    unsigned int data = cache_data(nway, nset, nword - 1);
     
    854854    inline void printTrace()
    855855    {
    856         for (size_t way = 0; way < m_ways ; way++) 
     856        for (size_t way = 0; way < m_ways ; way++)
    857857        {
    858858            for (size_t set = 0 ; set < m_sets ; set++)
    859859            {
    860860                addr_t addr = (((addr_t)cache_tag(way,set))*m_words*m_sets+m_words*set)*4;
    861                 std::cout << std::dec << cache_state(way, set) 
    862                           << " | way " << way 
    863                           << " | set " << set 
     861                std::cout << std::dec << cache_state(way, set)
     862                          << " | way " << way
     863                          << " | set " << set
    864864                          << std::hex << " | @ " << addr;
    865865
     
    872872        }
    873873    }
    874    
     874
    875875};
    876876
  • branches/RWT/modules/vci_mem_cache

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

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

    r495 r814  
    11#ifndef SOCLIB_CABA_MEM_CACHE_DIRECTORY_H
    2 #define SOCLIB_CABA_MEM_CACHE_DIRECTORY_H 
     2#define SOCLIB_CABA_MEM_CACHE_DIRECTORY_H
    33
    44#include <inttypes.h>
     
    1414
    1515  ////////////////////////////////////////////////////////////////////////
    16   //                    A LRU entry 
     16  //                    A LRU entry
    1717  ////////////////////////////////////////////////////////////////////////
    1818  class LruEntry {
     
    2020    public:
    2121
    22       bool recent;           
     22      bool recent;
    2323
    2424      void init()
     
    3333  ////////////////////////////////////////////////////////////////////////
    3434  class Owner{
    35    
     35
    3636    public:
    3737    // Fields
     
    6666
    6767  ////////////////////////////////////////////////////////////////////////
    68   //                    A directory entry                               
     68  //                    A directory entry
    6969  ////////////////////////////////////////////////////////////////////////
    7070  class DirectoryEntry {
     
    8181    tag_t   tag;                    // tag of the entry
    8282    size_t  count;                  // number of copies
    83     Owner   owner;                  // an owner of the line 
     83    Owner   owner;                  // an owner of the line
    8484    size_t  ptr;                    // pointer to the next owner
    8585
     
    109109      owner         = source.owner;
    110110      ptr           = source.ptr;
    111     }         
    112 
    113     /////////////////////////////////////////////////////////////////////
    114     // The init() function initializes the entry 
     111    }
     112
     113    /////////////////////////////////////////////////////////////////////
     114    // The init() function initializes the entry
    115115    /////////////////////////////////////////////////////////////////////
    116116    void init()
     
    125125
    126126    /////////////////////////////////////////////////////////////////////
    127     // The copy() function copies an existing source entry to a target 
     127    // The copy() function copies an existing source entry to a target
    128128    /////////////////////////////////////////////////////////////////////
    129129    void copy(const DirectoryEntry &source)
    130130    {
    131       valid         = source.valid;
     131      valid     = source.valid;
    132132      cache_coherent = source.cache_coherent;
    133133      is_cnt    = source.is_cnt;
    134       dirty         = source.dirty;
    135       lock          = source.lock;
    136       tag           = source.tag;
     134      dirty     = source.dirty;
     135      lock      = source.lock;
     136      tag       = source.tag;
    137137      count     = source.count;
    138138      owner     = source.owner;
     
    141141
    142142    ////////////////////////////////////////////////////////////////////
    143     // The print() function prints the entry 
     143    // The print() function prints the entry
    144144    ////////////////////////////////////////////////////////////////////
    145145    void print()
    146146    {
    147       std::cout << "Valid = " << valid 
     147      std::cout << "Valid = " << valid
    148148                << " ; COHERENCE = " << cache_coherent
    149                 << " ; IS COUNT = " << is_cnt 
    150                 << " ; Dirty = " << dirty 
    151                 << " ; Lock = " << lock 
    152                 << " ; Tag = " << std::hex << tag << std::dec 
    153                 << " ; Count = " << count 
    154                 << " ; Owner = " << owner.srcid 
    155                 << " " << owner.inst 
     149                << " ; IS COUNT = " << is_cnt
     150                << " ; Dirty = " << dirty
     151                << " ; Lock = " << lock
     152                << " ; Tag = " << std::hex << tag << std::dec
     153                << " ; Count = " << count
     154                << " ; Owner = " << owner.srcid
     155                << " " << owner.inst
    156156                << " ; Pointer = " << ptr << std::endl;
    157157    }
     
    160160
    161161  ////////////////////////////////////////////////////////////////////////
    162   //                       The directory 
     162  //                       The directory
    163163  ////////////////////////////////////////////////////////////////////////
    164164  class CacheDirectory {
     
    171171
    172172    // Directory constants
    173     size_t                                      m_ways;
    174     size_t                                      m_sets;
    175     size_t                                      m_words;
    176     size_t                                      m_width;
    177     uint32_t                lfsr;
     173    size_t   m_ways;
     174    size_t   m_sets;
     175    size_t   m_words;
     176    size_t   m_width;
     177    uint32_t lfsr;
    178178
    179179    // the directory & lru tables
    180     DirectoryEntry                              **m_dir_tab;
    181     LruEntry                                    **m_lru_tab;
     180    DirectoryEntry **m_dir_tab;
     181    LruEntry       **m_lru_tab;
    182182
    183183    public:
     
    186186    // Constructor
    187187    ////////////////////////
    188     CacheDirectory( size_t ways, size_t sets, size_t words, size_t address_width)       
    189     {
    190       m_ways  = ways; 
     188    CacheDirectory( size_t ways, size_t sets, size_t words, size_t address_width)
     189    {
     190      m_ways  = ways;
    191191      m_sets  = sets;
    192192      m_words = words;
     
    223223    // LRU is updated.
    224224    // Arguments :
    225     // - address : the address of the entry 
     225    // - address : the address of the entry
    226226    // - way : (return argument) the way of the entry in case of hit
    227     // The function returns a copy of a (valid or invalid) entry 
     227    // The function returns a copy of a (valid or invalid) entry
    228228    /////////////////////////////////////////////////////////////////////
    229229    DirectoryEntry read(const addr_t &address, size_t &way)
     
    240240        bool valid = m_dir_tab[set][i].valid;
    241241        hit = equal && valid;
    242         if ( hit ) {                   
     242        if ( hit ) {
    243243          way = i;
    244244          break;
    245         } 
     245        }
    246246      }
    247247      if ( hit ) {
     
    255255    /////////////////////////////////////////////////////////////////////
    256256    // The inval function invalidate an entry defined by the set and
    257     // way arguments. 
     257    // way arguments.
    258258    /////////////////////////////////////////////////////////////////////
    259259    void inval( const size_t &way, const size_t &set )
     
    266266    // changing the LRU
    267267    // Arguments :
    268     // - address : the address of the entry 
    269     // The function returns a copy of a (valid or invalid) entry 
    270     /////////////////////////////////////////////////////////////////////
    271     DirectoryEntry read_neutral( const addr_t &address, 
     268    // - address : the address of the entry
     269    // The function returns a copy of a (valid or invalid) entry
     270    /////////////////////////////////////////////////////////////////////
     271    DirectoryEntry read_neutral( const addr_t &address,
    272272                                 size_t*      ret_way,
    273273                                 size_t*      ret_set )
     
    279279#undef L2
    280280
    281         for ( size_t way = 0 ; way < m_ways ; way++ ) 
     281        for ( size_t way = 0 ; way < m_ways ; way++ )
    282282        {
    283283            bool equal = ( m_dir_tab[set][way].tag == tag );
     
    286286            {
    287287                *ret_set = set;
    288                 *ret_way = way; 
     288                *ret_way = way;
    289289                return DirectoryEntry(m_dir_tab[set][way]);
    290290            }
    291         } 
     291        }
    292292        return DirectoryEntry();
    293293    } // end read_neutral()
    294294
    295295    /////////////////////////////////////////////////////////////////////
    296     // The write function writes a new entry, 
     296    // The write function writes a new entry,
    297297    // and updates the LRU bits if necessary.
    298298    // Arguments :
     
    301301    // - entry : the entry value
    302302    /////////////////////////////////////////////////////////////////////
    303     void write( const size_t         &set, 
    304                 const size_t         &way, 
     303    void write( const size_t         &set,
     304                const size_t         &way,
    305305                const DirectoryEntry &entry)
    306306    {
    307       assert( (set<m_sets) 
     307      assert( (set<m_sets)
    308308          && "Cache Directory write : The set index is invalid");
    309       assert( (way<m_ways) 
     309      assert( (way<m_ways)
    310310          && "Cache Directory write : The way index is invalid");
    311311
     
    315315      // update LRU bits
    316316      bool all_recent = true;
    317       for ( size_t i=0 ; i<m_ways ; i++ ) 
     317      for ( size_t i=0 ; i<m_ways ; i++ )
    318318      {
    319319          if ( i != way ) all_recent = m_lru_tab[set][i].recent && all_recent;
    320320      }
    321       if ( all_recent ) 
     321      if ( all_recent )
    322322      {
    323323          for( size_t i=0 ; i<m_ways ; i++ ) m_lru_tab[set][i].recent = false;
    324       } 
    325       else 
     324      }
     325      else
    326326      {
    327327          m_lru_tab[set][way].recent = true;
     
    349349    DirectoryEntry select(const size_t &set, size_t &way)
    350350    {
    351         assert( (set < m_sets) 
     351        assert( (set < m_sets)
    352352          && "Cache Directory : (select) The set index is invalid");
    353353
     
    404404
    405405    /////////////////////////////////////////////////////////////////////
    406     //          Global initialisation function
     406    //               Global initialisation function
    407407    /////////////////////////////////////////////////////////////////////
    408408    void init()
    409409    {
    410       for ( size_t set=0 ; set<m_sets ; set++ ) 
    411       {
    412         for ( size_t way=0 ; way<m_ways ; way++ ) 
     410      for ( size_t set=0 ; set<m_sets ; set++ )
     411      {
     412        for ( size_t way=0 ; way<m_ways ; way++ )
    413413        {
    414414          m_dir_tab[set][way].init();
     
    446446        owner.inst  = entry.owner.inst;
    447447        owner.srcid = entry.owner.srcid;
    448         next           = entry.next;
     448        next        = entry.next;
    449449      } // end constructor
    450450
    451451    /////////////////////////////////////////////////////////////////////
    452     // The copy() function copies an existing source entry to a target 
     452    // The copy() function copies an existing source entry to a target
    453453    /////////////////////////////////////////////////////////////////////
    454454      void copy(const HeapEntry &entry)
    455455      {
    456         owner.inst     = entry.owner.inst;
    457         owner.srcid    = entry.owner.srcid;
    458         next           = entry.next;
     456        owner.inst  = entry.owner.inst;
     457        owner.srcid = entry.owner.srcid;
     458        next        = entry.next;
    459459      } // end copy()
    460460
    461461    ////////////////////////////////////////////////////////////////////
    462     // The print() function prints the entry 
     462    // The print() function prints the entry
    463463    ////////////////////////////////////////////////////////////////////
    464464      void print(){
    465         std::cout 
     465        std::cout
    466466        << " -- owner.inst     : " << std::dec << owner.inst << std::endl
    467467        << " -- owner.srcid    : " << std::dec << owner.srcid << std::endl
     
    473473
    474474  ////////////////////////////////////////////////////////////////////////
    475   //                        The Heap 
     475  //                        The Heap
    476476  ////////////////////////////////////////////////////////////////////////
    477477  class HeapDirectory{
    478    
     478
    479479    private:
    480480    // Registers and the heap
     
    506506
    507507    /////////////////////////////////////////////////////////////////////
    508     //          Global initialisation function
     508    //              Global initialisation function
    509509    /////////////////////////////////////////////////////////////////////
    510510      void init(){
     
    541541            if(ptr_temp == m_heap_tab[ptr_temp].next) end = true;
    542542            ptr_temp = m_heap_tab[ptr_temp].next;
    543         } 
     543        }
    544544      } // end print_list()
    545545
     
    552552
    553553    /////////////////////////////////////////////////////////////////////
    554     // The next_free_ptr() function returns the pointer 
     554    // The next_free_ptr() function returns the pointer
    555555    // to the next free entry.
    556556    /////////////////////////////////////////////////////////////////////
     
    560560
    561561    /////////////////////////////////////////////////////////////////////
    562     // The next_free_entry() function returns 
     562    // The next_free_entry() function returns
    563563    // a copy of the next free entry.
    564564    /////////////////////////////////////////////////////////////////////
     
    566566        return HeapEntry(m_heap_tab[ptr_free]);
    567567      } // end next_free_entry()
    568    
     568
    569569    /////////////////////////////////////////////////////////////////////
    570570    // The write_free_entry() function modify the next free entry.
     
    624624
    625625  ////////////////////////////////////////////////////////////////////////
    626   //                        Cache Data 
    627   ////////////////////////////////////////////////////////////////////////
    628   class CacheData 
     626  //                        Cache Data
     627  ////////////////////////////////////////////////////////////////////////
     628  class CacheData
    629629  {
    630630    private:
     
    639639      ///////////////////////////////////////////////////////
    640640      CacheData(uint32_t ways, uint32_t sets, uint32_t words)
    641         : m_sets(sets), m_ways(ways), m_words(words) 
     641        : m_sets(sets), m_ways(ways), m_words(words)
    642642      {
    643643          m_cache_data = new uint32_t ** [ways];
    644           for ( size_t i=0 ; i < ways ; i++ ) 
     644          for ( size_t i=0 ; i < ways ; i++ )
    645645          {
    646646              m_cache_data[i] = new uint32_t * [sets];
    647647          }
    648           for ( size_t i=0; i<ways; i++ ) 
     648          for ( size_t i=0; i<ways; i++ )
    649649          {
    650               for ( size_t j=0; j<sets; j++ ) 
     650              for ( size_t j=0; j<sets; j++ )
    651651              {
    652652                  m_cache_data[i][j] = new uint32_t [words];
     
    655655      }
    656656      ////////////
    657       ~CacheData() 
     657      ~CacheData()
    658658      {
    659659          for(size_t i=0; i<m_ways ; i++)
     
    673673      uint32_t read ( const uint32_t &way,
    674674                      const uint32_t &set,
    675                       const uint32_t &word) const 
     675                      const uint32_t &word) const
    676676      {
    677677          assert((set  < m_sets ) && "Cache data error: Trying to read a wrong set" );
     
    697697                   const uint32_t &word,
    698698                   const uint32_t &data,
    699                    const uint32_t &be = 0xF) 
     699                   const uint32_t &be = 0xF)
    700700      {
    701701
     
    707707          if (be == 0x0) return;
    708708
    709           if (be == 0xF) 
     709          if (be == 0xF)
    710710          {
    711               m_cache_data[way][set][word] = data; 
     711              m_cache_data[way][set][word] = data;
    712712              return;
    713713          }
     
    719719          if  (be & 0x8) mask = mask | 0xFF000000;
    720720
    721           m_cache_data[way][set][word] = 
     721          m_cache_data[way][set][word] =
    722722              (data & mask) | (m_cache_data[way][set][word] & ~mask);
    723723      }
  • branches/RWT/modules/vci_mem_cache/caba/source/include/update_tab.h

    r767 r814  
    88
    99////////////////////////////////////////////////////////////////////////
    10 //                  An update tab entry   
     10//                  An update tab entry
    1111////////////////////////////////////////////////////////////////////////
    1212class UpdateTabEntry {
     
    1717  public:
    1818
    19   bool      valid;      // It is a valid pending transaction
    20   bool      update;     // It is an update transaction
    21   bool      brdcast;    // It is a broadcast invalidate
    22   bool      rsp;        // Response to the initiator required
    23   bool      ack;        // Acknowledge to the CONFIG FSM required
    24   size_t        srcid;      // The srcid of the initiator which wrote the data
    25   size_t        trdid;      // The trdid of the initiator which wrote the data
    26   size_t        pktid;      // The pktid of the initiator which wrote the data
    27   addr_t        nline;      // The identifier of the cache line
    28   size_t        count;      // The number of acknowledge responses to receive
     19  bool   valid;   // It is a valid pending transaction
     20  bool   update;  // It is an update transaction
     21  bool   brdcast; // It is a broadcast invalidate
     22  bool   rsp;     // Response to the initiator required
     23  bool   ack;     // Acknowledge to the CONFIG FSM required
     24  size_t srcid;   // The srcid of the initiator which wrote the data
     25  size_t trdid;   // The trdid of the initiator which wrote the data
     26  size_t pktid;   // The pktid of the initiator which wrote the data
     27  addr_t nline;   // The identifier of the cache line
     28  size_t count;   // The number of acknowledge responses to receive
    2929
    3030  UpdateTabEntry()
    3131  {
    32     valid       = false;
     32    valid   = false;
    3333    update  = false;
    3434    brdcast = false;
    3535    rsp     = false;
    3636    ack     = false;
    37     srcid       = 0;
    38     trdid       = 0;
    39     pktid       = 0;
    40     nline       = 0;
    41     count       = 0;
    42   }
    43 
    44   UpdateTabEntry(bool   i_valid, 
     37    srcid   = 0;
     38    trdid   = 0;
     39    pktid   = 0;
     40    nline   = 0;
     41    count   = 0;
     42  }
     43
     44  UpdateTabEntry(bool   i_valid,
    4545                 bool   i_update,
    4646                 bool   i_brdcast,
    4747                 bool   i_rsp,
    4848                 bool   i_ack,
    49                  size_t i_srcid, 
    50                  size_t i_trdid, 
    51                  size_t i_pktid, 
     49                 size_t i_srcid,
     50                 size_t i_trdid,
     51                 size_t i_pktid,
    5252                 addr_t i_nline,
    53                  size_t i_count) 
    54   {
    55     valid       = i_valid;
    56     update      = i_update;
     53                 size_t i_count)
     54  {
     55    valid   = i_valid;
     56    update  = i_update;
    5757    brdcast = i_brdcast;
    5858    rsp     = i_rsp;
    5959    ack     = i_ack;
    60     srcid       = i_srcid;
    61     trdid       = i_trdid;
    62     pktid       = i_pktid;
    63     nline       = i_nline;
    64     count       = i_count;
     60    srcid   = i_srcid;
     61    trdid   = i_trdid;
     62    pktid   = i_pktid;
     63    nline   = i_nline;
     64    count   = i_count;
    6565  }
    6666
     
    8080
    8181  ////////////////////////////////////////////////////
    82   // The init() function initializes the entry 
     82  // The init() function initializes the entry
    8383  ///////////////////////////////////////////////////
    8484  void init()
    8585  {
    86     valid  = false;
    87     update = false;
    88     brdcast= false;
    89     rsp    = false;
    90     ack    = false;
    91     srcid  = 0;
    92     trdid  = 0;
    93     pktid  = 0;
    94     nline  = 0;
    95     count  = 0;
     86    valid   = false;
     87    update  = false;
     88    brdcast = false;
     89    rsp     = false;
     90    ack     = false;
     91    srcid   = 0;
     92    trdid   = 0;
     93    pktid   = 0;
     94    nline   = 0;
     95    count   = 0;
    9696  }
    9797
     
    116116
    117117  ////////////////////////////////////////////////////////////////////
    118   // The print() function prints the entry 
     118  // The print() function prints the entry
    119119  ////////////////////////////////////////////////////////////////////
    120120  void print()
    121121  {
    122     std::cout << " val = " << std::dec << valid 
    123               << " / updt = " << update 
     122    std::cout << " val = " << std::dec << valid
     123              << " / updt = " << update
    124124              << " / bc = " << brdcast
    125               << " / rsp = " << rsp 
    126               << " / ack = " << ack   
     125              << " / rsp = " << rsp
     126              << " / ack = " << ack
    127127              << " / count = " << count
    128               << " / srcid = " << std::hex << srcid 
    129               << " / trdid = " << trdid   
     128              << " / srcid = " << std::hex << srcid
     129              << " / trdid = " << trdid
    130130              << " / pktid = " << pktid
    131131              << " / nline = " << nline  << std::endl;
     
    134134
    135135////////////////////////////////////////////////////////////////////////
    136 //                        The update tab             
     136//                        The update tab
    137137////////////////////////////////////////////////////////////////////////
    138138class UpdateTab{
     
    159159
    160160  ////////////////////////////////////////////////////////////////////
    161   // The size() function returns the size of the tab 
     161  // The size() function returns the size of the tab
    162162  ////////////////////////////////////////////////////////////////////
    163163  const size_t size()
     
    167167
    168168  ////////////////////////////////////////////////////////////////////
    169   // The print() function diplays the tab content 
     169  // The print() function diplays the tab content
    170170  ////////////////////////////////////////////////////////////////////
    171171  void print()
    172172  {
    173173    std::cout << "UPDATE TABLE Content" << std::endl;
    174     for(size_t i=0; i<size_tab; i++) 
     174    for(size_t i=0; i<size_tab; i++)
    175175    {
    176176      std::cout << "[" << std::dec << i << "] ";
     
    181181
    182182  /////////////////////////////////////////////////////////////////////
    183   // The init() function initializes the tab 
     183  // The init() function initializes the tab
    184184  /////////////////////////////////////////////////////////////////////
    185185  void init()
     
    189189
    190190  /////////////////////////////////////////////////////////////////////
    191   // The reads() function reads an entry 
     191  // The reads() function reads an entry
    192192  // Arguments :
    193193  // - entry : the entry to read
     
    211211  // This function returns true if the write successed (an entry was empty).
    212212  ///////////////////////////////////////////////////////////////////////////
    213   bool set(const bool   update,
     213  bool set(const bool   update,
    214214           const bool   brdcast,
    215215           const bool   rsp,
     
    222222           size_t       &index)
    223223  {
    224     for ( size_t i=0 ; i<size_tab ; i++ ) 
    225     {
    226       if( !tab[i].valid ) 
     224    for ( size_t i=0 ; i<size_tab ; i++ )
     225    {
     226      if( !tab[i].valid )
    227227      {
    228         tab[i].valid            = true;
    229         tab[i].update           = update;
    230         tab[i].brdcast      = brdcast;
    231         tab[i].rsp          = rsp;
    232         tab[i].ack          = ack;
    233         tab[i].srcid            = (size_t) srcid;
    234         tab[i].trdid            = (size_t) trdid;
    235         tab[i].pktid            = (size_t) pktid;
    236         tab[i].nline            = (addr_t) nline;
    237         tab[i].count            = (size_t) count;
    238         index                       = i;
     228        tab[i].valid   = true;
     229        tab[i].update  = update;
     230        tab[i].brdcast = brdcast;
     231        tab[i].rsp     = rsp;
     232        tab[i].ack     = ack;
     233        tab[i].srcid   = (size_t) srcid;
     234        tab[i].trdid   = (size_t) trdid;
     235        tab[i].pktid   = (size_t) pktid;
     236        tab[i].nline   = (addr_t) nline;
     237        tab[i].count   = (size_t) count;
     238        index          = i;
    239239        return true;
    240240      }
     
    251251  /////////////////////////////////////////////////////////////////////
    252252  bool decrement( const size_t index,
    253                   size_t &counter ) 
     253                  size_t &counter )
    254254  {
    255255    assert((index<size_tab) && "Bad Update Tab Entry");
    256     if ( tab[index].valid ) 
     256    if ( tab[index].valid )
    257257    {
    258258      tab[index].count--;
    259259      counter = tab[index].count;
    260260      return true;
    261     } 
    262     else 
     261    }
     262    else
    263263    {
    264264      return false;
     
    298298  {
    299299    assert(index<size_tab && "Bad Update Tab Entry");
    300     return tab[index].rsp;     
     300    return tab[index].rsp;
    301301  }
    302302
     
    309309  {
    310310    assert(index<size_tab && "Bad Update Tab Entry");
    311     return tab[index].ack;     
     311    return tab[index].ack;
    312312  }
    313313
     
    320320  {
    321321    assert(index<size_tab && "Bad Update Tab Entry");
    322     return tab[index].brdcast; 
     322    return tab[index].brdcast;
    323323  }
    324324
     
    331331  {
    332332    assert(index<size_tab && "Bad Update Tab Entry");
    333     return tab[index].update;   
     333    return tab[index].update;
    334334  }
    335335
     
    342342  {
    343343    assert(index<size_tab && "Bad Update Tab Entry");
    344     return tab[index].srcid;   
     344    return tab[index].srcid;
    345345  }
    346346
     
    353353  {
    354354    assert(index<size_tab && "Bad Update Tab Entry");
    355     return tab[index].trdid;   
     355    return tab[index].trdid;
    356356  }
    357357
     
    364364  {
    365365    assert(index<size_tab && "Bad Update Tab Entry");
    366     return tab[index].pktid;   
     366    return tab[index].pktid;
    367367  }
    368368
     
    403403  // - nline : the line number of the entry in the directory
    404404  /////////////////////////////////////////////////////////////////////
    405   bool read_nline(const addr_t nline,size_t &index) 
     405  bool read_nline(const addr_t nline,size_t &index)
    406406  {
    407407    size_t i ;
     
    422422  // Arguments :
    423423  // - index : the index of the entry
    424   /////////////////////////////////////////////////////////////////////       
     424  /////////////////////////////////////////////////////////////////////
    425425  void clear(const size_t index)
    426426  {
    427427    assert(index<size_tab && "Bad Update Tab Entry");
    428428    tab[index].valid=false;
    429     return;     
     429    return;
    430430  }
    431431
  • branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r787 r814  
    2525 * SOCLIB_LGPL_HEADER_END
    2626 *
    27  * Maintainers: alain.greiner@lip6.fr 
     27 * Maintainers: alain.greiner@lip6.fr
    2828 *              eric.guthmuller@polytechnique.edu
    2929 *              cesar.fuguet-tortolero@lip6.fr
     
    6262  using namespace sc_core;
    6363
    64   template<typename vci_param_int, 
     64  template<typename vci_param_int,
    6565           typename vci_param_ext,
    6666           size_t   dspin_in_width,
     
    416416      };
    417417
    418       // debug variables 
     418      // debug variables
    419419      bool     m_debug;
    420420      bool     m_debug_previous_valid;
     
    479479      uint32_t m_cpt_heap_unused;             // NB cycles HEAP LOCK unused
    480480      uint32_t m_cpt_heap_slot_available;     // NB HEAP slot available refresh at each cycles
    481       uint32_t m_cpt_heap_min_slot_available; // NB HEAP : Min of slot available 
     481      uint32_t m_cpt_heap_min_slot_available; // NB HEAP : Min of slot available
    482482
    483483      uint32_t m_cpt_ncc_to_cc_read;         // NB change from NCC to CC caused by a READ
     
    525525
    526526#if MONITOR_MEMCACHE_FSM == 1
    527       sc_out<int> p_read_fsm; 
    528       sc_out<int> p_write_fsm; 
    529       sc_out<int> p_xram_rsp_fsm; 
    530       sc_out<int> p_cas_fsm; 
    531       sc_out<int> p_cleanup_fsm; 
    532       sc_out<int> p_config_fsm; 
    533       sc_out<int> p_alloc_heap_fsm; 
    534       sc_out<int> p_alloc_dir_fsm; 
    535       sc_out<int> p_alloc_trt_fsm; 
    536       sc_out<int> p_alloc_upt_fsm; 
    537       sc_out<int> p_alloc_ivt_fsm; 
    538       sc_out<int> p_tgt_cmd_fsm; 
    539       sc_out<int> p_tgt_rsp_fsm; 
    540       sc_out<int> p_ixr_cmd_fsm; 
    541       sc_out<int> p_ixr_rsp_fsm; 
    542       sc_out<int> p_cc_send_fsm; 
    543       sc_out<int> p_cc_receive_fsm; 
    544       sc_out<int> p_multi_ack_fsm; 
     527      sc_out<int> p_read_fsm;
     528      sc_out<int> p_write_fsm;
     529      sc_out<int> p_xram_rsp_fsm;
     530      sc_out<int> p_cas_fsm;
     531      sc_out<int> p_cleanup_fsm;
     532      sc_out<int> p_config_fsm;
     533      sc_out<int> p_alloc_heap_fsm;
     534      sc_out<int> p_alloc_dir_fsm;
     535      sc_out<int> p_alloc_trt_fsm;
     536      sc_out<int> p_alloc_upt_fsm;
     537      sc_out<int> p_alloc_ivt_fsm;
     538      sc_out<int> p_tgt_cmd_fsm;
     539      sc_out<int> p_tgt_rsp_fsm;
     540      sc_out<int> p_ixr_cmd_fsm;
     541      sc_out<int> p_ixr_rsp_fsm;
     542      sc_out<int> p_cc_send_fsm;
     543      sc_out<int> p_cc_receive_fsm;
     544      sc_out<int> p_multi_ack_fsm;
    545545#endif
    546546
     
    558558          const size_t                       max_copies,      // max number of copies
    559559          const size_t                       heap_size=HEAP_ENTRIES,
    560           const size_t                       trt_lines=TRT_ENTRIES, 
    561           const size_t                       upt_lines=UPT_ENTRIES,     
    562           const size_t                       ivt_lines=IVT_ENTRIES,     
     560          const size_t                       trt_lines=TRT_ENTRIES,
     561          const size_t                       upt_lines=UPT_ENTRIES,
     562          const size_t                       ivt_lines=IVT_ENTRIES,
    563563          const size_t                       debug_start_cycle=0,
    564564          const bool                         debug_ok=false );
     
    584584
    585585      // Component attributes
    586       std::list<soclib::common::Segment> m_seglist;          // segments allocated 
     586      std::list<soclib::common::Segment> m_seglist;          // segments allocated
    587587      size_t                             m_nseg;             // number of segments
    588588      soclib::common::Segment            **m_seg;            // array of segments pointers
     
    657657      // Fifo between CC_RECEIVE fsm and CLEANUP fsm
    658658      GenericFifo<uint64_t>  m_cc_receive_to_cleanup_fifo;
    659      
     659
    660660      // Fifo between CC_RECEIVE fsm and MULTI_ACK fsm
    661661      GenericFifo<uint64_t>  m_cc_receive_to_multi_ack_fifo;
     
    686686      sc_signal<int>      r_config_fsm;               // FSM state
    687687      sc_signal<bool>     r_config_lock;              // lock protecting exclusive access
    688       sc_signal<int>      r_config_cmd;               // config request type 
     688      sc_signal<int>      r_config_cmd;               // config request type
    689689      sc_signal<addr_t>   r_config_address;           // target buffer physical address
    690690      sc_signal<size_t>   r_config_srcid;             // config request srcid
     
    702702      sc_signal<size_t>   r_config_heap_next;         // current pointer to scan HEAP
    703703      sc_signal<size_t>   r_config_trt_index;         // selected entry in TRT
    704       sc_signal<size_t>   r_config_ivt_index;         // selected entry in IVT 
     704      sc_signal<size_t>   r_config_ivt_index;         // selected entry in IVT
    705705
    706706      // Buffer between CONFIG fsm and IXR_CMD fsm
     
    744744      sc_signal<addr_t>   r_read_ll_key;              // LL key from llsc_global_table
    745745
    746       // Buffer between READ fsm and IXR_CMD fsm 
     746      // Buffer between READ fsm and IXR_CMD fsm
    747747      sc_signal<bool>     r_read_to_ixr_cmd_req;      // valid request
    748748      sc_signal<size_t>   r_read_to_ixr_cmd_index;    // TRT index
     
    764764      sc_signal<bool>     r_read_to_cc_send_inst;
    765765
    766       //RWT: Buffer between READ fsm and CLEANUP fsm (wait for the data coming from L1 cache) 
     766      //RWT: Buffer between READ fsm and CLEANUP fsm (wait for the data coming from L1 cache)
    767767      sc_signal<bool>     r_read_to_cleanup_req;    // valid request
    768768      sc_signal<addr_t>   r_read_to_cleanup_nline;  // cache line index
     
    771771      sc_signal<size_t>   r_read_to_cleanup_length;
    772772      sc_signal<size_t>   r_read_to_cleanup_first_word;
    773       sc_signal<bool>     r_read_to_cleanup_cached_read;   
     773      sc_signal<bool>     r_read_to_cleanup_cached_read;
    774774      sc_signal<bool>     r_read_to_cleanup_is_ll;
    775775      sc_signal<addr_t>   r_read_to_cleanup_addr;
     
    810810      sc_signal<data_t>   r_write_sc_key;             // sc command key
    811811      sc_signal<bool>     r_write_bc_data_we;         // Write enable for data buffer
    812  
     812
    813813      // Buffer between WRITE fsm and TGT_RSP fsm (acknowledge a write command from L1)
    814814      sc_signal<bool>     r_write_to_tgt_rsp_req;     // valid request
     
    818818      sc_signal<bool>     r_write_to_tgt_rsp_sc_fail; // sc command failed
    819819
    820       // Buffer between WRITE fsm and IXR_CMD fsm 
     820      // Buffer between WRITE fsm and IXR_CMD fsm
    821821      sc_signal<bool>     r_write_to_ixr_cmd_req;     // valid request
    822       sc_signal<size_t>   r_write_to_ixr_cmd_index;   // TRT index 
     822      sc_signal<size_t>   r_write_to_ixr_cmd_index;   // TRT index
    823823
    824824      // Buffer between WRITE fsm and CC_SEND fsm (Update/Invalidate L1 caches)
     
    908908      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
    909909      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
    910       sc_signal<addr_t>     r_cleanup_to_tgt_rsp_ll_key;
     910      sc_signal<addr_t>   r_cleanup_to_tgt_rsp_ll_key;
    911911
    912912      //RWT
     
    948948      // Buffer between CAS fsm and IXR_CMD fsm (XRAM write)
    949949      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
    950       sc_signal<size_t>   r_cas_to_ixr_cmd_index; // TRT index 
     950      sc_signal<size_t>   r_cas_to_ixr_cmd_index; // TRT index
    951951
    952952      // Buffer between CAS fsm and TGT_RSP fsm
     
    978978
    979979      // Buffer between IXR_RSP fsm and CONFIG fsm  (response from the XRAM)
    980       sc_signal<bool>     r_ixr_rsp_to_config_ack;      // one single bit   
     980      sc_signal<bool>     r_ixr_rsp_to_config_ack;      // one single bit
    981981
    982982      // Buffer between IXR_RSP fsm and XRAM_RSP fsm  (response from the XRAM)
     
    10281028      GenericFifo<size_t> m_xram_rsp_to_cc_send_srcid_fifo;    // fifo for srcids
    10291029
    1030       // Buffer between XRAM_RSP fsm and IXR_CMD fsm 
     1030      // Buffer between XRAM_RSP fsm and IXR_CMD fsm
    10311031      sc_signal<bool>     r_xram_rsp_to_ixr_cmd_req;   // Valid request
    1032       sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_index; // TRT index 
     1032      sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_index; // TRT index
    10331033
    10341034      //RWT
     
    10411041      sc_signal<int>      r_ixr_cmd_fsm;
    10421042      sc_signal<size_t>   r_ixr_cmd_word;              // word index for a put
    1043       sc_signal<size_t>   r_ixr_cmd_trdid;             // TRT index value     
     1043      sc_signal<size_t>   r_ixr_cmd_trdid;             // TRT index value
    10441044      sc_signal<addr_t>   r_ixr_cmd_address;           // address to XRAM
    10451045      sc_signal<data_t> * r_ixr_cmd_wdata;             // cache line buffer
     
    11121112      sc_signal<data_t>    *r_cleanup_old_data;
    11131113      sc_signal<bool>      r_cleanup_contains_data;
    1114      
     1114
    11151115      sc_signal<bool>      r_cleanup_ncc;
    11161116      sc_signal<bool>      r_cleanup_to_ixr_cmd_ncc_l1_dirty;
    11171117      sc_signal<bool>      r_xram_rsp_to_ixr_cmd_inval_ncc_pending;
    1118      
     1118
    11191119      sc_signal<bool>      r_cleanup_to_ixr_cmd_req;
    11201120      sc_signal<data_t>    *r_cleanup_to_ixr_cmd_data;
  • branches/RWT/modules/vci_mem_cache/caba/source/include/xram_transaction.h

    r767 r814  
    1010
    1111////////////////////////////////////////////////////////////////////////
    12 //                  A transaction tab entry         
     12//                  A transaction tab entry
    1313////////////////////////////////////////////////////////////////////////
    1414
    15 class TransactionTabEntry 
     15class TransactionTabEntry
    1616{
    1717    typedef sc_dt::sc_uint<64>    wide_data_t;
     
    2121
    2222    public:
    23     bool                        valid;              // entry valid
    24     bool                        xram_read;          // read request to XRAM
    25     addr_t              nline;              // index (zy) of the requested line
    26     size_t                  srcid;          // processor requesting the transaction
    27     size_t                  trdid;          // processor requesting the transaction
    28     size_t                  pktid;          // processor requesting the transaction
    29     bool                        proc_read;          // read request from processor
    30     size_t                  read_length;    // length of the read (for the response)
    31     size_t                  word_index;         // index of the first read word (for the response)
    32     std::vector<data_t> wdata;          // write buffer (one cache line)
    33     std::vector<be_t>   wdata_be;       // be for each data in the write buffer
    34     bool                rerror;         // error returned by xram
    35     data_t              ll_key;         // LL key returned by the llsc_global_table
    36     bool                config;         // transaction required by CONFIG FSM
    37 
    38     /////////////////////////////////////////////////////////////////////
    39     // The init() function initializes the entry 
     23    bool                valid;       // entry valid
     24    bool                xram_read;   // read request to XRAM
     25    addr_t              nline;       // index (zy) of the requested line
     26    size_t              srcid;       // processor requesting the transaction
     27    size_t              trdid;       // processor requesting the transaction
     28    size_t              pktid;       // processor requesting the transaction
     29    bool                proc_read;   // read request from processor
     30    size_t              read_length; // length of the read (for the response)
     31    size_t              word_index;  // index of the first read word (for the response)
     32    std::vector<data_t> wdata;       // write buffer (one cache line)
     33    std::vector<be_t>   wdata_be;    // be for each data in the write buffer
     34    bool                rerror;      // error returned by xram
     35    data_t              ll_key;      // LL key returned by the llsc_global_table
     36    bool                config;      // transaction required by CONFIG FSM
     37
     38    /////////////////////////////////////////////////////////////////////
     39    // The init() function initializes the entry
    4040    /////////////////////////////////////////////////////////////////////
    4141    void init()
    4242    {
    43         valid           = false;
    44         rerror      = false;
    45         config      = false;
     43        valid  = false;
     44        rerror = false;
     45        config = false;
    4646    }
    4747
     
    6969    void copy(const TransactionTabEntry &source)
    7070    {
    71         valid       = source.valid;
    72         xram_read       = source.xram_read;
    73         nline       = source.nline;
    74         srcid       = source.srcid;
    75         trdid       = source.trdid;
    76         pktid       = source.pktid;
    77         proc_read       = source.proc_read;
     71        valid       = source.valid;
     72        xram_read   = source.xram_read;
     73        nline       = source.nline;
     74        srcid       = source.srcid;
     75        trdid       = source.trdid;
     76        pktid       = source.pktid;
     77        proc_read   = source.proc_read;
    7878        read_length = source.read_length;
    79         word_index      = source.word_index;
     79        word_index  = source.word_index;
    8080        wdata_be.assign(source.wdata_be.begin(),source.wdata_be.end());
    8181        wdata.assign(source.wdata.begin(),source.wdata.end());
     
    8686
    8787    ////////////////////////////////////////////////////////////////////
    88     // The print() function prints the entry 
     88    // The print() function prints the entry
    8989    ////////////////////////////////////////////////////////////////////
    9090    void print()
     
    9999        std::cout << "proc_read   = " << proc_read    << std::endl;
    100100        std::cout << "read_length = " << read_length  << std::endl;
    101         std::cout << "word_index  = " << word_index   << std::endl; 
     101        std::cout << "word_index  = " << word_index   << std::endl;
    102102        for(size_t i=0; i<wdata_be.size() ; i++)
    103103        {
    104             std::cout << "wdata_be[" << std::dec << i << "] = " 
     104            std::cout << "wdata_be[" << std::dec << i << "] = "
    105105                      << std::hex << wdata_be[i] << std::endl;
    106106        }
    107107        for(size_t i=0; i<wdata.size() ; i++)
    108108        {
    109             std::cout << "wdata[" << std::dec << i << "] = " 
     109            std::cout << "wdata[" << std::dec << i << "] = "
    110110                      << std::hex << wdata[i] << std::endl;
    111111        }
     
    117117
    118118    /////////////////////////////////////////////////////////////////////
    119     //          Constructors
     119    // Constructors
    120120    /////////////////////////////////////////////////////////////////////
    121121
     
    131131    TransactionTabEntry(const TransactionTabEntry &source)
    132132    {
    133         valid       = source.valid;
    134         xram_read       = source.xram_read;
    135         nline       = source.nline;
    136         srcid       = source.srcid;
    137         trdid       = source.trdid;
    138         pktid       = source.pktid;
    139         proc_read       = source.proc_read;
     133        valid       = source.valid;
     134        xram_read   = source.xram_read;
     135        nline       = source.nline;
     136        srcid       = source.srcid;
     137        trdid       = source.trdid;
     138        pktid       = source.pktid;
     139        proc_read   = source.proc_read;
    140140        read_length = source.read_length;
    141         word_index      = source.word_index;
     141        word_index  = source.word_index;
    142142        wdata_be.assign(source.wdata_be.begin(),source.wdata_be.end());
    143         wdata.assign(source.wdata.begin(),source.wdata.end()); 
     143        wdata.assign(source.wdata.begin(),source.wdata.end());
    144144        rerror      = source.rerror;
    145145        ll_key      = source.ll_key;
     
    150150
    151151////////////////////////////////////////////////////////////////////////
    152 //                  The transaction tab                             
     152//                  The transaction tab
    153153////////////////////////////////////////////////////////////////////////
    154154class TransactionTab
     
    185185
    186186    ////////////////////////////////////////////////////////////////////
    187     //          Constructors
     187    //  Constructors
    188188    ////////////////////////////////////////////////////////////////////
    189189    TransactionTab()
     
    194194
    195195    TransactionTab(const std::string &name,
    196                    size_t            n_entries, 
     196                   size_t            n_entries,
    197197                   size_t            n_words )
    198198    : tab_name( name ),
    199       size_tab( n_entries ) 
     199      size_tab( n_entries )
    200200    {
    201201        tab = new TransactionTabEntry[size_tab];
    202         for ( size_t i=0; i<size_tab; i++) 
     202        for ( size_t i=0; i<size_tab; i++)
    203203        {
    204204            tab[i].alloc(n_words);
     
    222222    void init()
    223223    {
    224         for ( size_t i=0; i<size_tab; i++) 
     224        for ( size_t i=0; i<size_tab; i++)
    225225        {
    226226            tab[i].init();
     
    247247    TransactionTabEntry read(const size_t index)
    248248    {
    249         assert( (index < size_tab) and 
     249        assert( (index < size_tab) and
    250250        "MEMC ERROR: Invalid Transaction Tab Entry");
    251251
     
    255255    // The full() function returns the state of the transaction tab
    256256    // Arguments :
    257     // - index : (return argument) the index of an empty entry 
     257    // - index : (return argument) the index of an empty entry
    258258    // The function returns true if the transaction tab is full
    259259    /////////////////////////////////////////////////////////////////////
     
    265265            {
    266266                index=i;
    267                 return false;   
     267                return false;
    268268            }
    269269        }
     
    271271    }
    272272    /////////////////////////////////////////////////////////////////////
    273     // The hit_read() function checks if an XRAM read transaction exists 
     273    // The hit_read() function checks if an XRAM read transaction exists
    274274    // for a given cache line.
    275275    // Arguments :
    276     // - index : (return argument) the index of the hit entry, if there is 
     276    // - index : (return argument) the index of the hit entry, if there is
    277277    // - nline : the index (zy) of the requested line
    278278    // The function returns true if a read request has already been sent
     
    282282        for(size_t i=0; i<size_tab; i++)
    283283        {
    284             if((tab[i].valid && (nline==tab[i].nline)) && (tab[i].xram_read)) 
     284            if((tab[i].valid && (nline==tab[i].nline)) && (tab[i].xram_read))
    285285            {
    286286                index=i;
    287                 return true;   
     287                return true;
    288288            }
    289289        }
     
    291291    }
    292292    ///////////////////////////////////////////////////////////////////////
    293     // The hit_write() function looks if an XRAM write transaction exists 
     293    // The hit_write() function looks if an XRAM write transaction exists
    294294    // for a given line.
    295295    // Arguments :
     
    301301        for(size_t i=0; i<size_tab; i++)
    302302        {
    303             if(tab[i].valid && (nline==tab[i].nline) && !(tab[i].xram_read)) 
     303            if(tab[i].valid && (nline==tab[i].nline) && !(tab[i].xram_read))
    304304            {
    305                 return true;   
     305                return true;
    306306            }
    307307        }
     
    310310
    311311    ///////////////////////////////////////////////////////////////////////
    312     // The hit_write() function looks if an XRAM write transaction exists 
     312    // The hit_write() function looks if an XRAM write transaction exists
    313313    // for a given line.
    314314    // Arguments :
     
    322322            if(tab[i].valid && (nline==tab[i].nline) && !(tab[i].xram_read)) {
    323323                *index = i;
    324                 return true;   
     324                return true;
    325325            }
    326326        }
     
    330330    // The write_data_mask() function writes a vector of data (a line).
    331331    // The data is written only if the corresponding bits are set
    332     // in the be vector. 
     332    // in the be vector.
    333333    // Arguments :
    334334    // - index : the index of the request in the transaction tab
    335     // - be   : vector of be 
     335    // - be   : vector of be
    336336    // - data : vector of data
    337337    /////////////////////////////////////////////////////////////////////
    338     void write_data_mask(const size_t index, 
    339             const std::vector<be_t> &be, 
    340             const std::vector<data_t> &data) 
     338    void write_data_mask(const size_t index,
     339            const std::vector<be_t> &be,
     340            const std::vector<data_t> &data)
    341341    {
    342342        assert( (index < size_tab) and
     
    349349        "MEMC ERROR: Bad data size in TRT write_data_mask()");
    350350
    351         for(size_t i=0; i<tab[index].wdata_be.size() ; i++) 
     351        for(size_t i=0; i<tab[index].wdata_be.size() ; i++)
    352352        {
    353353            tab[index].wdata_be[i] = tab[index].wdata_be[i] | be[i];
     
    384384            const size_t word_index,
    385385            const std::vector<be_t> &data_be,
    386             const std::vector<data_t> &data, 
     386            const std::vector<data_t> &data,
    387387            const data_t ll_key = 0,
    388             const bool config = false) 
     388            const bool config = false)
    389389    {
    390390        assert( (index < size_tab) and
    391391        "MEMC ERROR: The selected entry is out of range in TRT set()");
    392392
    393         assert( (data_be.size()==tab[index].wdata_be.size()) and 
     393        assert( (data_be.size()==tab[index].wdata_be.size()) and
    394394        "MEMC ERROR: Bad data_be argument in TRT set()");
    395395
    396         assert( (data.size()==tab[index].wdata.size()) and 
     396        assert( (data.size()==tab[index].wdata.size()) and
    397397        "MEMC ERROR: Bad data argument in TRT set()");
    398398
    399         tab[index].valid                = true;
    400         tab[index].xram_read        = xram_read;
    401         tab[index].nline                = nline;
    402         tab[index].srcid                = srcid;
    403         tab[index].trdid                = trdid;
    404         tab[index].pktid                = pktid;
    405         tab[index].proc_read        = proc_read;
    406         tab[index].read_length      = read_length;
    407         tab[index].word_index       = word_index;
    408         tab[index].ll_key           = ll_key;
    409         tab[index].config           = config;
    410         for(size_t i=0; i<tab[index].wdata.size(); i++) 
     399        tab[index].valid       = true;
     400        tab[index].xram_read   = xram_read;
     401        tab[index].nline       = nline;
     402        tab[index].srcid       = srcid;
     403        tab[index].trdid       = trdid;
     404        tab[index].pktid       = pktid;
     405        tab[index].proc_read   = proc_read;
     406        tab[index].read_length = read_length;
     407        tab[index].word_index  = word_index;
     408        tab[index].ll_key      = ll_key;
     409        tab[index].config      = config;
     410        for(size_t i=0; i<tab[index].wdata.size(); i++)
    411411        {
    412412            tab[index].wdata_be[i]    = data_be[i];
     
    416416
    417417    /////////////////////////////////////////////////////////////////////
    418     // The write_rsp() function writes two 32 bits words of the response 
     418    // The write_rsp() function writes two 32 bits words of the response
    419419    // to a XRAM read transaction.
    420420    // The BE field in TRT is taken into account.
     
    435435        "MEMC ERROR: The selected entry is out of range in TRT write_rsp()");
    436436
    437         assert( (word < tab[index].wdata_be.size()) and 
     437        assert( (word < tab[index].wdata_be.size()) and
    438438        "MEMC ERROR: Bad word index in TRT write_rsp()");
    439439
     
    467467    void erase(const size_t index)
    468468    {
    469         assert( (index < size_tab) and 
     469        assert( (index < size_tab) and
    470470        "MEMC ERROR: The selected entry is out of range in TRT erase()");
    471471
    472         tab[index].valid        = false;
    473         tab[index].rerror   = false;
     472        tab[index].valid  = false;
     473        tab[index].rerror = false;
    474474    }
    475475    /////////////////////////////////////////////////////////////////////
  • branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r787 r814  
    135135        "MULTI_ACK_UPT_LOCK",
    136136        "MULTI_ACK_UPT_CLEAR",
    137         "MULTI_ACK_WRITE_RSP",
     137        "MULTI_ACK_WRITE_RSP"
    138138    };
    139139    const char *config_fsm_str[] =
     
    496496#if MONITOR_MEMCACHE_FSM == 1
    497497            ,
    498         p_read_fsm("p_read_fsm"), 
    499         p_write_fsm("p_write_fsm"), 
    500         p_xram_rsp_fsm("p_xram_rsp_fsm"), 
    501         p_cas_fsm("p_cas_fsm"), 
    502         p_cleanup_fsm("p_cleanup_fsm"), 
    503         p_config_fsm("p_config_fsm"), 
    504         p_alloc_heap_fsm("p_alloc_heap_fsm"), 
    505         p_alloc_dir_fsm("p_alloc_dir_fsm"), 
    506         p_alloc_trt_fsm("p_alloc_trt_fsm"), 
    507         p_alloc_upt_fsm("p_alloc_upt_fsm"), 
    508         p_alloc_ivt_fsm("p_alloc_ivt_fsm"), 
    509         p_tgt_cmd_fsm("p_tgt_cmd_fsm"), 
    510         p_tgt_rsp_fsm("p_tgt_rsp_fsm"), 
    511         p_ixr_cmd_fsm("p_ixr_cmd_fsm"), 
    512         p_ixr_rsp_fsm("p_ixr_rsp_fsm"), 
    513         p_cc_send_fsm("p_cc_send_fsm"), 
     498        p_read_fsm("p_read_fsm"),
     499        p_write_fsm("p_write_fsm"),
     500        p_xram_rsp_fsm("p_xram_rsp_fsm"),
     501        p_cas_fsm("p_cas_fsm"),
     502        p_cleanup_fsm("p_cleanup_fsm"),
     503        p_config_fsm("p_config_fsm"),
     504        p_alloc_heap_fsm("p_alloc_heap_fsm"),
     505        p_alloc_dir_fsm("p_alloc_dir_fsm"),
     506        p_alloc_trt_fsm("p_alloc_trt_fsm"),
     507        p_alloc_upt_fsm("p_alloc_upt_fsm"),
     508        p_alloc_ivt_fsm("p_alloc_ivt_fsm"),
     509        p_tgt_cmd_fsm("p_tgt_cmd_fsm"),
     510        p_tgt_rsp_fsm("p_tgt_rsp_fsm"),
     511        p_ixr_cmd_fsm("p_ixr_cmd_fsm"),
     512        p_ixr_rsp_fsm("p_ixr_rsp_fsm"),
     513        p_cc_send_fsm("p_cc_send_fsm"),
    514514        p_cc_receive_fsm("p_cc_receive_fsm"),
    515515        p_multi_ack_fsm("p_multi_ack_fsm")
     
    629629            {
    630630                m_debug_data[word] = m_cache_data.read(way, set, word);
    631                 if ( m_debug_previous_valid and 
     631                if ( m_debug_previous_valid and
    632632                        (m_debug_data[word] != m_debug_previous_data[word]) )
    633633                {
     
    647647                << " / VAL = " << std::dec << entry.valid
    648648                << " / WAY = " << way
    649                 << " / COUNT = " << entry.count 
     649                << " / COUNT = " << entry.count
    650650                << " / DIRTY = " << entry.dirty
    651                 << " / DATA_CHANGE = " << data_change 
     651                << " / DATA_CHANGE = " << data_change
    652652                << std::endl;
    653653            std::cout << std::hex << "     /0:" << m_debug_data[0]
     
    672672        m_debug_previous_valid = entry.valid;
    673673        m_debug_previous_dirty = entry.dirty;
    674         for( size_t word=0 ; word<m_words ; word++ ) 
     674        for( size_t word=0 ; word<m_words ; word++ )
    675675            m_debug_previous_data[word] = m_debug_data[word];
    676676    }
     
    840840    }
    841841
    842    
     842
    843843    /////////////////////////////////////////
    844844    tmpl(void)::reset_counters()
     
    874874        m_cpt_update_remote       = 0;
    875875        m_cpt_update_cost         = 0;
    876        
     876
    877877        m_cpt_minval              = 0;
    878878        m_cpt_minval_local        = 0;
     
    893893        m_cpt_write_miss          = 0;
    894894        m_cpt_write_dirty         = 0;
    895        
     895
    896896        m_cpt_trt_rb              = 0;
    897897        m_cpt_trt_full            = 0;
     
    13291329        // The READ/WRITE commands accepted in the configuration segment are targeting
    13301330        // configuration or status registers. They must contain one single flit.
    1331         // - For almost all addressable registers, the response is returned immediately. 
     1331        // - For almost all addressable registers, the response is returned immediately.
    13321332        // - For MEMC_CMD_TYPE, the response is delayed until the operation is completed.
    13331333        ////////////////////////////////////////////////////////////////////////////////////
     
    13661366                        else                       r_tgt_cmd_fsm = TGT_CMD_CONFIG;
    13671367                    }
    1368                     else                            //////////// memory access 
     1368                    else                            //////////// memory access
    13691369                    {
    13701370                        if ( p_vci_tgt.cmd.read() == vci_param_int::CMD_READ )
     
    14111411
    14121412                            if((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
    1413                             else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE; 
     1413                            else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE;
    14141414                        }
    14151415                        else
     
    15091509                                  m_config_func_idx_mask;
    15101510
    1511                     bool     need_rsp; 
    1512                     int      error; 
     1511                    bool     need_rsp;
     1512                    int      error;
    15131513                    uint32_t rdata = 0;         // default value
    15141514                    uint32_t wdata = p_vci_tgt.wdata.read();
     
    16171617
    16181618                                        break;
    1619                                        
     1619
    16201620                                    default:
    16211621                                        error = 1;
     
    17191719                    size_t   cell     = (address - seg_base)/vci_param_int::B;
    17201720
    1721                     bool     need_rsp; 
    1722                     size_t   error; 
     1721                    bool     need_rsp;
     1722                    size_t   error;
    17231723                    uint32_t rdata = 0;         // default value
    1724                     uint32_t wdata = p_vci_tgt.wdata.read();     
     1724                    uint32_t wdata = p_vci_tgt.wdata.read();
    17251725
    17261726                    if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
     
    18301830                        << " read command packet must contain one single flit" << std::endl;
    18311831                    exit(0);
    1832                 } 
     1832                }
    18331833                // check plen for LL
    1834                 if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and 
     1834                if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
    18351835                        (p_vci_tgt.plen.read() != 8) )
    18361836                {
     
    18671867                    }
    18681868                    else {
    1869                         if (is_local_req(p_vci_tgt.srcid.read())) 
     1869                        if (is_local_req(p_vci_tgt.srcid.read()))
    18701870                        {
    18711871                            m_cpt_read_local++;
     
    19101910                            m_cpt_write_flits_local++;
    19111911                        }
    1912                         else 
     1912                        else
    19131913                        {
    19141914                            m_cpt_write_flits_remote++;
     
    19261926                                m_cpt_sc_local++;
    19271927                            }
    1928                             else 
     1928                            else
    19291929                            {
    19301930                                m_cpt_sc_remote++;
     
    19321932                        }
    19331933                        else {
    1934                             if (is_local_req(p_vci_tgt.srcid.read())) 
     1934                            if (is_local_req(p_vci_tgt.srcid.read()))
    19351935                            {
    19361936                                m_cpt_write_local++;
     
    19731973                    if (p_vci_tgt.eop) {
    19741974                        // <Activity counters>
    1975                         if (is_local_req(p_vci_tgt.srcid.read())) 
     1975                        if (is_local_req(p_vci_tgt.srcid.read()))
    19761976                        {
    19771977                            m_cpt_cas_local++;
     
    19931993        //    MULTI_ACK FSM
    19941994        /////////////////////////////////////////////////////////////////////////
    1995         // This FSM controls the response to the multicast update requests sent 
     1995        // This FSM controls the response to the multicast update requests sent
    19961996        // by the memory cache to the L1 caches and update the UPT.
    19971997        //
     
    21332133                /////////////////////////
    21342134            case MULTI_ACK_WRITE_RSP:     // Post a response request to TGT_RSP FSM
    2135                 // Wait if pending request 
     2135                // Wait if pending request
    21362136                {
    21372137                    if ( r_multi_ack_to_tgt_rsp_req.read() ) break;
     
    21682168
    21692169        //
    2170         // For both INVAL and SYNC commands, the CONFIG FSM contains the loop handling 
     2170        // For both INVAL and SYNC commands, the CONFIG FSM contains the loop handling
    21712171        //
    21722172        // all cache lines covered by the buffer. The various lines of a given buffer
    21732173        // can be pipelined: the CONFIG FSM does not wait the response for line (n) to send
    2174         // the command for line (n+1). It decrements the r_config_cmd_lines counter until 
     2174        // the command for line (n+1). It decrements the r_config_cmd_lines counter until
    21752175        // the last request has been registered in TRT (for a SYNC), or in IVT (for an INVAL).
    21762176        // The r_config_rsp_lines counter contains the number of expected responses from
     
    21802180        // be concurently accessed by those three FSMs, it is implemented as an [incr/decr]
    21812181        // counter.
    2182         // 
     2182        //
    21832183        // - INVAL request:
    2184         //   For each line, it access to the DIR. 
    2185         //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM. 
     2184        //   For each line, it access to the DIR.
     2185        //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM.
    21862186        //   In case of hit, with no copies in L1 caches, the line is invalidated and
    21872187        //   a response is requested to TGT_RSP FSM.
     
    21952195        //   This constraint can be released, but it requires to make 2 PUT transactions
    21962196        //   for the first and the last line...
    2197         // 
     2197        //
    21982198        // - SYNC request:
    2199         //   For each line, it access to the DIR. 
    2200         //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM. 
     2199        //   For each line, it access to the DIR.
     2200        //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM.
    22012201        //   In case of hit, a PUT transaction is registered in TRT and a request is sent
    22022202        //   to IXR_CMD FSM. The IXR_RSP FSM decrements the r_config_rsp_lines counter
     
    22052205        //
    22062206        // From the software point of view, a configuration request is a sequence
    2207         // of 6 atomic accesses in an uncached segment. A dedicated lock is used 
     2207        // of 6 atomic accesses in an uncached segment. A dedicated lock is used
    22082208        // to handle only one configuration command at a given time:
    22092209        // - Read  MEMC_LOCK       : Get the lock
     
    22182218        {
    22192219            /////////////////
    2220             case CONFIG_IDLE:  // waiting a config request 
    2221                 {
    2222                     if ( r_config_cmd.read() != MEMC_CMD_NOP ) 
     2220            case CONFIG_IDLE:  // waiting a config request
     2221                {
     2222                    if ( r_config_cmd.read() != MEMC_CMD_NOP )
    22232223                    {
    22242224                        r_config_fsm    = CONFIG_LOOP;
     
    22262226#if DEBUG_MEMC_CONFIG
    22272227                        if(m_debug)
    2228                             std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received" 
     2228                            std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received"
    22292229                                << " address = " << std::hex << r_config_address.read()
    22302230                                << " / nlines = " << std::dec << r_config_cmd_lines.read()
     
    22352235                }
    22362236                /////////////////
    2237             case CONFIG_LOOP:   // test last line to be handled 
     2237            case CONFIG_LOOP:   // test last line to be handled
    22382238                {
    22392239                    if ( r_config_cmd_lines.read() == 0 )
     
    22492249#if DEBUG_MEMC_CONFIG
    22502250                    if(m_debug)
    2251                         std::cout << "  <MEMC " << name() << " CONFIG_LOOP>" 
    2252                             << " address = " << std::hex << r_config_address.read()   
    2253                             << " / nlines = " << std::dec << r_config_cmd_lines.read() 
     2251                        std::cout << "  <MEMC " << name() << " CONFIG_LOOP>"
     2252                            << " address = " << std::hex << r_config_address.read()
     2253                            << " / nlines = " << std::dec << r_config_cmd_lines.read()
    22542254                            << " / command = " << r_config_cmd.read() << std::endl;
    22552255#endif
     
    22572257                }
    22582258                /////////////////
    2259             case CONFIG_WAIT:   // wait completion (last response) 
     2259            case CONFIG_WAIT:   // wait completion (last response)
    22602260                {
    22612261                    if ( r_config_rsp_lines.read() == 0 )  // last response received
     
    22662266#if DEBUG_MEMC_CONFIG
    22672267                    if(m_debug)
    2268                         std::cout << "  <MEMC " << name() << " CONFIG_WAIT>" 
     2268                        std::cout << "  <MEMC " << name() << " CONFIG_WAIT>"
    22692269                            << " / lines to do = " << std::dec << r_config_rsp_lines.read() << std::endl;
    22702270#endif
     
    22722272                }
    22732273                ////////////////
    2274             case CONFIG_RSP:  // request TGT_RSP FSM to return response 
     2274            case CONFIG_RSP:  // request TGT_RSP FSM to return response
    22752275                {
    22762276                    if ( not r_config_to_tgt_rsp_req.read() )
     
    23292329
    23302330                    if (entry.valid and                            // hit & inval command
    2331                             (r_config_cmd.read() == MEMC_CMD_INVAL)) 
     2331                            (r_config_cmd.read() == MEMC_CMD_INVAL))
    23322332                    {
    23332333                        r_config_fsm    = CONFIG_IVT_LOCK;
     
    23362336                            entry.dirty and
    23372337                            (r_config_cmd.read() == MEMC_CMD_SYNC) )
    2338                     { 
     2338                    {
    23392339                        r_config_fsm = CONFIG_TRT_LOCK;
    23402340                    }
    2341                     else                                            // return to LOOP 
     2341                    else                                            // return to LOOP
    23422342                    {
    23432343                        r_config_cmd_lines = r_config_cmd_lines.read() - 1;
     
    23592359                /////////////////////
    23602360            case CONFIG_TRT_LOCK:      // enter this state in case of SYNC command
    2361                 // to a dirty cache line 
     2361                // to a dirty cache line
    23622362                // keep DIR lock, and try to get TRT lock
    23632363                // return to LOOP state if TRT full
     
    24232423                    std::vector<data_t> data_vector;
    24242424                    data_vector.clear();
    2425                     for(size_t word=0; word<m_words; word++) 
     2425                    for(size_t word=0; word<m_words; word++)
    24262426                    {
    24272427                        uint32_t data = m_cache_data.read( way, set, word );
     
    24392439                            0,                                   // read_length: unused
    24402440                            0,                                   // word_index:  unused
    2441                             std::vector<be_t>(m_words,0xF),      // byte-enable:     unused 
     2441                            std::vector<be_t>(m_words,0xF),      // byte-enable:     unused
    24422442                            data_vector,                         // data to be written
    24432443                            0,                                   // ll_key:          unused
     
    24702470                        if(m_debug)
    24712471                            std::cout << "  <MEMC " << name() << " CONFIG_PUT_REQ> post PUT request to IXR_CMD_FSM"
    2472                                 << " / address = " << std::hex << r_config_address.read() << std::endl; 
     2472                                << " / address = " << std::hex << r_config_address.read() << std::endl;
    24732473#endif
    24742474                    }
     
    24802480                // Return to LOOP state if IVT full.
    24812481                // Register inval in IVT, and invalidate the
    2482                 // directory if IVT not full. 
     2482                // directory if IVT not full.
    24832483                {
    24842484                    assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
     
    25152515
    25162516                            wok = m_ivt.set(false,       // it's an inval transaction
    2517                                     broadcast,   
     2517                                    broadcast,
    25182518                                    false,       // no response required
    25192519                                    true,        // acknowledge required
     
    25582558            case CONFIG_BC_SEND:    // Post a broadcast inval request to CC_SEND FSM
    25592559                {
    2560                     if( not r_config_to_cc_send_multi_req.read() and 
     2560                    if( not r_config_to_cc_send_multi_req.read() and
    25612561                            not r_config_to_cc_send_brdcast_req.read() )
    25622562                    {
     
    25752575                        if(m_debug)
    25762576                            std::cout << "  <MEMC " << name() << " CONFIG_BC_SEND>"
    2577                                 << " Post a broadcast inval request to CC_SEND FSM" 
     2577                                << " Post a broadcast inval request to CC_SEND FSM"
    25782578                                << " / address = " << r_config_address.read() <<std::endl;
    25792579#endif
     
    25842584            case CONFIG_INVAL_SEND:    // Post a multi inval request to CC_SEND FSM
    25852585                {
    2586                     if( not r_config_to_cc_send_multi_req.read() and 
     2586                    if( not r_config_to_cc_send_multi_req.read() and
    25872587                            not r_config_to_cc_send_brdcast_req.read() )
    25882588                    {
     
    26122612                        if(m_debug)
    26132613                            std::cout << "  <MEMC " << name() << " CONFIG_INVAL_SEND>"
    2614                                 << " Post multi inval request to CC_SEND FSM" 
    2615                                 << " / address = " << std::hex << r_config_address.read() 
    2616                                 << " / copy = " << r_config_dir_copy_srcid.read() 
     2614                                << " Post multi inval request to CC_SEND FSM"
     2615                                << " / address = " << std::hex << r_config_address.read()
     2616                                << " / copy = " << r_config_dir_copy_srcid.read()
    26172617                                << " / inst = " << std::dec << r_config_dir_copy_inst.read() << std::endl;
    26182618#endif
     
    26402640                {
    26412641                    HeapEntry entry = m_heap.read( r_config_heap_next.read() );
    2642                     bool last_copy  = (entry.next == r_config_heap_next.read()); 
     2642                    bool last_copy  = (entry.next == r_config_heap_next.read());
    26432643
    26442644                    config_to_cc_send_fifo_srcid = entry.owner.srcid;
     
    26602660                    if(m_debug)
    26612661                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_SCAN>"
    2662                             << " Post multi inval request to CC_SEND FSM" 
    2663                             << " / address = " << std::hex << r_config_address.read() 
    2664                             << " / copy = " << entry.owner.srcid 
     2662                            << " Post multi inval request to CC_SEND FSM"
     2663                            << " / address = " << std::hex << r_config_address.read()
     2664                            << " / copy = " << entry.owner.srcid
    26652665                            << " / inst = " << std::dec << entry.owner.inst << std::endl;
    26662666#endif
     
    26812681                    }
    26822682                    else
    2683                     { 
     2683                    {
    26842684                        last_entry.next = free_pointer;
    26852685                    }
     
    27992799
    28002800                        // hit on a WT line or the owner has no more copy (if LL, the owner must be invalidated even if he made the request)
    2801                         if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read())) 
     2801                        if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
    28022802                        {
    28032803                            // test if we need to register a new copy in the heap
     
    28512851                            {
    28522852                                std::cout
    2853                                     << "  <MEMC " << name() << " READ_IVT_LOCK>" 
     2853                                    << "  <MEMC " << name() << " READ_IVT_LOCK>"
    28542854                                    << " Wait cleanup completion"
    28552855                                    << std::endl;
     
    28622862                            r_read_to_cc_send_dest = r_read_copy.read();
    28632863                            r_read_to_cc_send_nline = nline;
    2864                             r_read_to_cc_send_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0); 
     2864                            r_read_to_cc_send_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    28652865                            r_read_to_cleanup_req = true;
    28662866                            r_read_to_cleanup_nline = nline;
    28672867                            r_read_to_cleanup_srcid = m_cmd_read_srcid_fifo.read();
    2868                             r_read_to_cleanup_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0); 
     2868                            r_read_to_cleanup_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    28692869                            r_read_to_cleanup_length  = m_cmd_read_length_fifo.read();
    28702870                            r_read_to_cleanup_first_word = m_x[(addr_t) m_cmd_read_addr_fifo.read()];
     
    29202920                    break;
    29212921                }
    2922                 ///////////////////                     
     2922                ///////////////////
    29232923            case READ_DIR_HIT:    //  read data in cache & update the directory
    29242924                //  we enter this state in 3 cases:
     
    30243024                        bool go_cnt = (r_read_count.read() >= m_max_copies) or m_heap.is_full();
    30253025
    3026                         if (!r_read_coherent.read())
    3027                         {
    3028                             std::cout << "Address = " << std::hex << (m_cmd_read_addr_fifo.read()) << std::dec << " |count = " << r_read_count.read() << std::endl;
    3029                         }
    3030                         assert (r_read_coherent.read() && "accÚs au heap sur ncc");
     3026                        assert (r_read_coherent.read() && "Heap access on line NCC");
    30313027                        // read data in the cache
    30323028                        size_t set = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
     
    31353131                            m_heap.set_full();
    31363132                        }
    3137                        
     3133
    31383134                        // <Activity counters>
    31393135                        m_cpt_heap_slot_available--;
     
    34183414                            << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
    34193415                            << " / address = " << std::hex << m_cmd_write_addr_fifo.read()
    3420                             << " / data = " << m_cmd_write_data_fifo.read() 
    3421                             << " / pktid = " << m_cmd_write_pktid_fifo.read() 
     3416                            << " / data = " << m_cmd_write_data_fifo.read()
     3417                            << " / pktid = " << m_cmd_write_pktid_fifo.read()
    34223418                            << std::endl;
    34233419#endif
     
    34313427
    34323428                    // check that the next word is in the same cache line
    3433                     assert((m_nline[(addr_t)(r_write_address.read())] == 
     3429                    assert((m_nline[(addr_t)(r_write_address.read())] ==
    34343430                                m_nline[(addr_t)(m_cmd_write_addr_fifo.read())]) &&
    34353431                            "MEMC ERROR in WRITE_NEXT state: Illegal write burst");
     
    34823478                        // test address and key match of the SC command on the
    34833479                        // LL/SC table without removing reservation. The reservation
    3484                         // will be erased after in this FSM. 
     3480                        // will be erased after in this FSM.
    34853481                        bool sc_success = m_llsc_table.check(r_write_address.read(),
    34863482                                r_write_sc_key.read());
     
    34933489                    else
    34943490                    {
    3495                         // write burst 
     3491                        // write burst
    34963492#define L2 soclib::common::uint32_log2
    34973493                        addr_t min = r_write_address.read();
     
    35943590                        addr_t nline = m_nline[(addr_t)(r_write_address.read())];
    35953591
    3596                         //if there is a matched updt req, we should wait until it is over. Because 
     3592                        //if there is a matched updt req, we should wait until it is over. Because
    35973593                        //we need the lastest updt data.
    35983594                        match_inval = m_ivt.search_inval(nline, index);
     
    36003596                        assert ((r_write_count.read() == 1) and "NCC to CC req without copy");
    36013597
    3602                         if( not match_inval                          and 
     3598                        if( not match_inval                          and
    36033599                            not m_ivt.is_full()                      and
    36043600                            not r_write_to_cc_send_req.read()        and
     
    36763672                    // no_update is true when there is no need for coherence transaction
    36773673                    bool no_update = ( (r_write_count.read() == 0) or
    3678                             (owner and (r_write_count.read() == 1) and 
     3674                            (owner and (r_write_count.read() == 1) and
    36793675                             ((r_write_pktid.read() & 0x7) != TYPE_SC)));
    36803676
     
    36823678                    if(no_update)
    36833679                    {
    3684                         // SC command but zero copies 
     3680                        // SC command but zero copies
    36853681                        if ((r_write_pktid.read() & 0x7) == TYPE_SC)
    36863682                        {
     
    37263722                        if(no_update)
    37273723                        {
    3728                             std::cout << "  <MEMC " << name() 
     3724                            std::cout << "  <MEMC " << name()
    37293725                                << " WRITE_DIR_HIT> Write into cache / No coherence transaction"
    37303726                                << std::endl;
     
    37613757                                true,  // response required
    37623758                                false, // no acknowledge required
    3763                                 srcid,   
     3759                                srcid,
    37643760                                trdid,
    37653761                                pktid,
     
    37923788                            if(wok)
    37933789                            {
    3794                                 std::cout << "  <MEMC " << name() 
     3790                                std::cout << "  <MEMC " << name()
    37953791                                    << " WRITE_UPT_LOCK> Register the multicast update in UPT / "
    37963792                                    << " nb_copies = " << r_write_count.read() << std::endl;
     
    38143810#if DEBUG_MEMC_WRITE
    38153811                        if(m_debug)
    3816                             std::cout << "  <MEMC " << name() 
     3812                            std::cout << "  <MEMC " << name()
    38173813                                << " WRITE_UPT_HEAP_LOCK> Get acces to the HEAP" << std::endl;
    38183814#endif
     
    39063902
    39073903                    // put the next srcid in the fifo
    3908                     if ((entry.owner.srcid != r_write_srcid.read()) or 
     3904                    if ((entry.owner.srcid != r_write_srcid.read()) or
    39093905                            ((r_write_pktid.read() & 0x7) == TYPE_SC)    or
    39103906                            entry.owner.inst)
     
    40264022
    40274023                                r_write_sc_key = m_cmd_write_data_fifo.read();
    4028                             } 
     4024                            }
    40294025
    40304026                            // initialize the be field for all words
     
    40494045                        {
    40504046                            std::cout << "  <MEMC " << name() << " WRITE_RSP> Post a request to TGT_RSP FSM"
    4051                                 << " : rsrcid = " << std::hex << r_write_srcid.read() 
    4052                                 << " : rpktid = " << std::hex << r_write_pktid.read() 
     4047                                << " : rsrcid = " << std::hex << r_write_srcid.read()
     4048                                << " : rpktid = " << std::hex << r_write_pktid.read()
    40534049                                << " : sc_fail= " << std::hex << r_write_sc_fail.read()
    40544050                                << std::endl;
     
    40584054                                    << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
    40594055                                    << " / address = " << m_cmd_write_addr_fifo.read()
    4060                                     << " / data = " << m_cmd_write_data_fifo.read() 
    4061                                     << " / pktid = " << m_cmd_write_pktid_fifo.read() 
     4056                                    << " / data = " << m_cmd_write_data_fifo.read()
     4057                                    << " / pktid = " << m_cmd_write_pktid_fifo.read()
    40624058                                    << std::endl;
    40634059                            }
     
    40684064                }
    40694065                ///////////////////////// RWT
    4070             case WRITE_MISS_IVT_LOCK: 
     4066            case WRITE_MISS_IVT_LOCK:
    40714067                {
    40724068                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
     
    42244220#if DEBUG_MEMC_WRITE
    42254221                        if(m_debug)
    4226                             std::cout << "  <MEMC " << name() 
     4222                            std::cout << "  <MEMC " << name()
    42274223                                << " WRITE_MISS_XRAM_REQ> Post a GET request to the"
    42284224                                << " IXR_CMD FSM" << std::endl;
     
    42824278#if DEBUG_MEMC_WRITE
    42834279                        if(m_debug)
    4284                             std::cout 
     4280                            std::cout
    42854281                                << "  <MEMC "  << name()
    42864282                                << " WRITE_BC_TRT_LOCK> Complete data buffer" << std::endl;
     
    44764472        //
    44774473        // - It sends a single flit VCI read to the XRAM in case of
    4478         //   GET request posted by the READ, WRITE or CAS FSMs. 
     4474        //   GET request posted by the READ, WRITE or CAS FSMs.
    44794475        // - It sends a multi-flit VCI write in case of PUT request posted by
    44804476        //   the XRAM_RSP, WRITE, CAS, or CONFIG FSMs.
     
    45354531                else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    45364532                else if(r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4537                 break;     
     4533                break;
    45384534                /////////////////////////
    45394535            case IXR_CMD_CONFIG_IDLE:
     
    45974593                }
    45984594                /////////////////////
    4599             case IXR_CMD_CAS_TRT:       // access TRT for a PUT or a GET 
     4595            case IXR_CMD_CAS_TRT:       // access TRT for a PUT or a GET
    46004596                {
    46014597                    if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     
    46244620                }
    46254621                //////////////////////
    4626             case IXR_CMD_XRAM_TRT:       // access TRT for a PUT 
     4622            case IXR_CMD_XRAM_TRT:       // access TRT for a PUT
    46274623                {
    46284624                    if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     
    46464642                }
    46474643                //////////////////////
    4648             case IXR_CMD_CLEANUP_TRT:       // access TRT for a PUT 
     4644            case IXR_CMD_CLEANUP_TRT:       // access TRT for a PUT
    46494645                {
    46504646                    if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     
    48664862        // The FSM takes the lock protecting the TRT, and the corresponding
    48674863        // entry is erased. If an acknowledge was required (in case of software SYNC)
    4868         // the r_config_rsp_lines counter is decremented. 
     4864        // the r_config_rsp_lines counter is decremented.
    48694865        //
    48704866        // - A response to a GET request is a multi-cell VCI packet.
     
    48734869        // The FSM takes the lock protecting the TRT to store the line in the TRT
    48744870        // (taking into account the write requests already stored in the TRT).
    4875         // When the line is completely written, the r_ixr_rsp_to_xram_rsp_rok[index] 
     4871        // When the line is completely written, the r_ixr_rsp_to_xram_rsp_rok[index]
    48764872        // signal is set to inform the XRAM_RSP FSM.
    48774873        ///////////////////////////////////////////////////////////////////////////////
     
    49024898                                    << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
    49034899#endif
    4904                         }     
    4905                     } 
     4900                        }
     4901                    }
    49064902                    break;
    49074903                }
     
    49194915                    if(r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
    49204916                    {
    4921                         size_t  index = r_ixr_rsp_trt_index.read(); 
     4917                        size_t  index = r_ixr_rsp_trt_index.read();
    49224918                        if (m_trt.is_config(index))     // it's a config transaction
    49234919                        {
     
    49774973        // The cache line has been written in the TRT by the IXR_CMD_FSM.
    49784974        // As the IXR_RSP FSM and the XRAM_RSP FSM are running in parallel,
    4979         // there is as many flip-flops r_ixr_rsp_to_xram_rsp_rok[i] as the number 
     4975        // there is as many flip-flops r_ixr_rsp_to_xram_rsp_rok[i] as the number
    49804976        // of entries in the TRT, that are handled with a round-robin priority...
    49814977        //
     
    50185014                            break;
    50195015                        }
    5020                     } 
     5016                    }
    50215017                    break;
    50225018                }
     
    50745070                    r_xram_rsp_victim_inval     = inval ;
    50755071                    // a NCC line is by default considered as dirty in the L1: we must take a reservation on a TRT entry
    5076                     r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1)); 
     5072                    r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1));
    50775073
    50785074
    50795075                    // A line that undergoes a change in its state (ncc to cc), should not be evicted from the memory cache.
    5080                     if((victim.tag * m_sets + set) == r_read_to_cleanup_nline.read() and r_read_to_cleanup_req.read()) 
     5076                    if((victim.tag * m_sets + set) == r_read_to_cleanup_nline.read() and r_read_to_cleanup_req.read())
    50815077                    {
    50825078                        r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    50905086#endif
    50915087                    }
    5092                     else if( not r_xram_rsp_trt_buf.rerror ) 
     5088                    else if( not r_xram_rsp_trt_buf.rerror )
    50935089                    {
    50945090                        r_xram_rsp_fsm = XRAM_RSP_IVT_LOCK;
    50955091                    }
    5096                     else 
     5092                    else
    50975093                    {
    50985094                        r_xram_rsp_fsm = XRAM_RSP_ERROR_ERASE;
     
    51115107                }
    51125108                ///////////////////////
    5113             case XRAM_RSP_IVT_LOCK:   // Keep DIR and TRT locks and take the IVT lock 
     5109            case XRAM_RSP_IVT_LOCK:   // Keep DIR and TRT locks and take the IVT lock
    51145110                // to check a possible pending inval
    51155111                {
     
    52415237                        bool   wok = m_ivt.set(false,      // it's an inval transaction
    52425238                                broadcast,  // set broadcast bit
    5243                                 false,      // no response required 
    5244                                 false,      // no acknowledge required 
     5239                                false,      // no response required
     5240                                false,      // no acknowledge required
    52455241                                0,          // srcid
    52465242                                0,          // trdid
     
    52525248                        r_xram_rsp_ivt_index = index;
    52535249                        assert( wok and
    5254                                 "MEMC ERROR in XRAM_RSP_DIR_UPDT state: IVT should not be full"); 
     5250                                "MEMC ERROR in XRAM_RSP_DIR_UPDT state: IVT should not be full");
    52555251
    52565252                    }
     
    53135309                                0,                                 // unused
    53145310                                0,                                 // unused
    5315                                 std::vector<be_t>(m_words,0xF),                         
     5311                                std::vector<be_t>(m_words,0xF),
    53165312                                data_vector);
    53175313#if DEBUG_MEMC_XRAM_RSP
     
    54115407                        m_cpt_write_dirty++;
    54125408
    5413                         bool multi_req = not r_xram_rsp_victim_is_cnt.read() and 
     5409                        bool multi_req = not r_xram_rsp_victim_is_cnt.read() and
    54145410                            r_xram_rsp_victim_inval.read();
    54155411                        bool not_last_multi_req = multi_req and (r_xram_rsp_victim_count.read() != 1);
     
    55405536                        // acknowledged before signaling another one.
    55415537                        // Therefore, when there is an active error, and other
    5542                         // errors arrive, these are not considered 
     5538                        // errors arrive, these are not considered
    55435539
    55445540                        if (!r_xram_rsp_rerror_irq.read() && r_xram_rsp_rerror_irq_enable.read()
     
    56395635                    r_cleanup_inst  = (type == DspinRwtParam::TYPE_CLEANUP_INST);
    56405636                    r_cleanup_srcid = srcid;
    5641                     r_cleanup_ncc = 
     5637                    r_cleanup_ncc =
    56425638                        DspinRwtParam::dspin_get(
    56435639                                flit,
     
    57385734                        uint64_t flit = m_cc_receive_to_cleanup_fifo.read();
    57395735
    5740                         uint32_t data = 
     5736                        uint32_t data =
    57415737                            DspinRwtParam::dspin_get (flit, DspinRwtParam::CLEANUP_DATA_UPDT);
    57425738
     
    58095805                    //RWT
    58105806                    size_t set = m_y[(addr_t)(cleanup_address)];
    5811                     m_cache_data.read_line(way, set, r_cleanup_old_data); 
     5807                    m_cache_data.read_line(way, set, r_cleanup_old_data);
    58125808                    r_cleanup_coherent = entry.cache_coherent;
    58135809
     
    59115907                    entry.lock           = r_cleanup_lock.read();
    59125908                    entry.ptr            = r_cleanup_ptr.read();
    5913                     if (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) //pending READ 
     5909                    if (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) //pending READ
    59145910                    {
    59155911                        if (r_read_to_cleanup_cached_read.read())
     
    59375933
    59385934#if REVERT_CC_MECANISM
    5939                         // Revert CC to NCC if : 
     5935                        // Revert CC to NCC if :
    59405936                        //  - no more copy in L1 caches
    59415937                        //  - this line is not in counter mode (broadcast)
     
    59485944
    59495945#if REVERT_BC_MECANISM
    5950                         if ((r_cleanup_count.read() - 1) == 0) 
     5946                        if ((r_cleanup_count.read() - 1) == 0)
    59515947                        {
    59525948                            entry.is_cnt = false;
     
    60826078                        {
    60836079                            r_cleanup_to_tgt_rsp_data[i] = r_cleanup_old_data[i].read();
    6084                         }       
     6080                        }
    60856081                    }
    60866082
     
    63546350                //////////////////////
    63556351            case CLEANUP_IVT_LOCK:   // get the lock protecting the IVT to search a pending
    6356                 // invalidate transaction matching the cleanup 
     6352                // invalidate transaction matching the cleanup
    63576353                {
    63586354                    if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
     
    64326428                }
    64336429                ///////////////////////
    6434             case CLEANUP_IVT_CLEAR:    // Clear IVT entry 
     6430            case CLEANUP_IVT_CLEAR:    // Clear IVT entry
    64356431                {
    64366432                    assert( (r_alloc_ivt_fsm.read() == ALLOC_IVT_CLEANUP) and
     
    64736469                    r_cleanup_to_tgt_rsp_trdid   = r_cleanup_write_trdid.read();
    64746470                    r_cleanup_to_tgt_rsp_pktid   = r_cleanup_write_pktid.read();
    6475                     r_cleanup_to_tgt_rsp_type    = true; 
     6471                    r_cleanup_to_tgt_rsp_type    = true;
    64766472
    64776473                    if (r_cleanup_ncc.read() )
     
    65036499                        {
    65046500                            size_t index = 0;
    6505                             bool   hit   = m_trt.hit_write(r_cleanup_nline.read(), &index); 
     6501                            bool   hit   = m_trt.hit_write(r_cleanup_nline.read(), &index);
    65066502
    65076503                            assert (hit and "CLEANUP_IXR_REQ found no matching entry in TRT");
     
    65106506
    65116507                            if (r_cleanup_contains_data.read())
    6512                             { 
     6508                            {
    65136509                                std::vector<data_t> data_vector;
    65146510                                data_vector.clear();
     
    65876583                            << " nline = "   << std::hex << r_cleanup_nline.read()
    65886584                            << " / way = "   << std::dec << r_cleanup_way.read()
    6589                             << " / srcid = " << std::dec << r_cleanup_srcid.read() 
     6585                            << " / srcid = " << std::dec << r_cleanup_srcid.read()
    65906586                            << std::endl;
    65916587#endif
     
    68056801                            if(m_debug)
    68066802                                std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE>"
    6807                                     << " Broacast Inval required" 
     6803                                    << " Broacast Inval required"
    68086804                                    << " / copies = " << r_cas_count.read() << std::endl;
    68096805#endif
     
    68176813                            if(m_debug)
    68186814                                std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE>"
    6819                                     << " Multi Inval required" 
     6815                                    << " Multi Inval required"
    68206816                                    << " / copies = " << r_cas_count.read() << std::endl;
    68216817#endif
     
    68746870                        wok = m_upt.set(true,    // it's an update transaction
    68756871                                false,   // it's not a broadcast
    6876                                 true,    // response required 
     6872                                true,    // response required
    68776873                                false,   // no acknowledge required
    68786874                                srcid,
     
    71377133                    {
    71387134                        if(i == word)                                        // first modified word
    7139                             data_vector.push_back( r_cas_wdata.read() );     
     7135                            data_vector.push_back( r_cas_wdata.read() );
    71407136                        else if((i == word+1) and (r_cas_cpt.read() == 4))   // second modified word
    71417137                            data_vector.push_back( m_cmd_cas_wdata_fifo.read() );
     
    71447140                    }
    71457141                    m_trt.set( r_cas_trt_index.read(),
    7146                             false,    // PUT request 
     7142                            false,    // PUT request
    71477143                            m_nline[(addr_t)(m_cmd_cas_addr_fifo.read())],
    71487144                            0,
     
    73647360        //
    73657361        // It implements a round-robin priority between the four possible client FSMs
    7366         //     XRAM_RSP > CAS > READ > WRITE > CONFIG 
     7362        //     XRAM_RSP > CAS > READ > WRITE > CONFIG
    73677363        //
    73687364        // Each FSM can request the next services:
     
    73757371        // - r_config_to_cc_send_multi_req : multi-inval
    73767372        //   r_config_to_cc_send_brdcast_req : broadcast-inval
    7377         //   
     7373        //
    73787374        // An inval request is a double DSPIN flit command containing:
    73797375        // 1. the index of the line to be invalidated.
     
    75177513                }
    75187514                ///////////////////////////
    7519             case CC_SEND_READ_IDLE: 
     7515            case CC_SEND_READ_IDLE:
    75207516                {
    75217517                    // WRITE
     
    82648260                    }
    82658261                    else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    8266                     else if(r_cleanup_to_tgt_rsp_req) 
     8262                    else if(r_cleanup_to_tgt_rsp_req)
    82678263                    {
    82688264                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     
    88098805        // - The XRAM_RSP FSM initiates broadcast/multicast invalidate transaction and sets
    88108806        //   a new entry in the IVT
    8811         // - The CONFIG FSM does the same thing as the XRAM_RSP FSM 
     8807        // - The CONFIG FSM does the same thing as the XRAM_RSP FSM
    88128808        // - The CLEANUP FSM complete those trasactions and erase the IVT entry.
    88138809        // The resource is always allocated.
     
    88448840                //////////////////////////
    88458841            case ALLOC_IVT_READ:            // allocated to READ FSM
    8846                 if (r_read_fsm.read() != READ_IVT_LOCK) 
     8842                if (r_read_fsm.read() != READ_IVT_LOCK)
    88478843                {
    88488844                    if (r_xram_rsp_fsm.read() == XRAM_RSP_IVT_LOCK)
     
    92319227                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    92329228
    9233                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9229                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    92349230                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    92359231
     
    92689264                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    92699265
    9270                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9266                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    92719267                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    92729268
     
    93049300                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    93059301
    9306                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9302                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    93079303                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    93089304
     
    93389334                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    93399335
    9340                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9336                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    93419337                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    93429338
     
    93699365                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    93709366
    9371                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9367                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    93729368                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    93739369
     
    94049400                        (r_ixr_rsp_fsm.read() != IXR_RSP_TRT_READ))
    94059401                {
    9406                     if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9402                    if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    94079403                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    94089404
     
    95069502                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    95079503
    9508                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9504                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    95099505                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    95109506                }
     
    96989694        /////////////////////////////////////////////////////////////////////
    96999695
    9700         m_cmd_read_addr_fifo.update(   cmd_read_fifo_get, cmd_read_fifo_put, 
     9696        m_cmd_read_addr_fifo.update(   cmd_read_fifo_get, cmd_read_fifo_put,
    97019697                p_vci_tgt.address.read() );
    9702         m_cmd_read_length_fifo.update( cmd_read_fifo_get, cmd_read_fifo_put, 
     9698        m_cmd_read_length_fifo.update( cmd_read_fifo_get, cmd_read_fifo_put,
    97039699                p_vci_tgt.plen.read()>>2 );
    9704         m_cmd_read_srcid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put, 
     9700        m_cmd_read_srcid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
    97059701                p_vci_tgt.srcid.read() );
    9706         m_cmd_read_trdid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put, 
     9702        m_cmd_read_trdid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
    97079703                p_vci_tgt.trdid.read() );
    9708         m_cmd_read_pktid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put, 
     9704        m_cmd_read_pktid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
    97099705                p_vci_tgt.pktid.read() );
    97109706
     
    97739769
    97749770        m_cc_receive_to_multi_ack_fifo.update( cc_receive_to_multi_ack_fifo_get,
    9775                 cc_receive_to_multi_ack_fifo_put, 
     9771                cc_receive_to_multi_ack_fifo_put,
    97769772                p_dspin_p2m.data.read() );
    97779773
     
    98179813        // The three sources of (increment / decrement) are CONFIG / CLEANUP / IXR_RSP FSMs
    98189814        ////////////////////////////////////////////////////////////////////////////////////
    9819         if ( config_rsp_lines_incr and not 
     9815        if ( config_rsp_lines_incr and not
    98209816             (config_rsp_lines_cleanup_decr or config_rsp_lines_ixr_rsp_decr) )
    98219817        {
    98229818            r_config_rsp_lines = r_config_rsp_lines.read() + 1;
    98239819        }
    9824         if ( not config_rsp_lines_incr and 
     9820        if ( not config_rsp_lines_incr and
    98259821             (config_rsp_lines_cleanup_decr or config_rsp_lines_ixr_rsp_decr) )
    98269822        {
     
    98309826        ////////////////////////////////////////////////////////////////////////////////////
    98319827        //            Update min m_cpt_heap_min_slot_available.
    9832         // The four sources of (increment / decrement) are READ / CLEANUP / XRAM_RSP / CONFIG FSMs 
     9828        // The four sources of (increment / decrement) are READ / CLEANUP / XRAM_RSP / CONFIG FSMs
    98339829        ////////////////////////////////////////////////////////////////////////////////////
    98349830        assert((m_cpt_heap_slot_available <= m_heap_size) and "m_cpt_heap_slot_available > m_heap_size");
     
    98689864        // DATA width is 8 bytes
    98699865        // The following values are not transmitted to XRAM
    9870         //   p_vci_ixr.be 
    9871         //   p_vci_ixr.pktid 
    9872         //   p_vci_ixr.cons 
    9873         //   p_vci_ixr.wrap 
    9874         //   p_vci_ixr.contig 
    9875         //   p_vci_ixr.clen 
    9876         //   p_vci_ixr.cfixed 
     9866        //   p_vci_ixr.be
     9867        //   p_vci_ixr.pktid
     9868        //   p_vci_ixr.cons
     9869        //   p_vci_ixr.wrap
     9870        //   p_vci_ixr.contig
     9871        //   p_vci_ixr.clen
     9872        //   p_vci_ixr.cfixed
    98779873
    98789874        p_vci_ixr.plen    = 64;
     
    98809876        p_vci_ixr.trdid   = r_ixr_cmd_trdid.read();
    98819877        p_vci_ixr.address = (addr_t)r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2);
    9882         p_vci_ixr.be      = 0xFF; 
     9878        p_vci_ixr.be      = 0xFF;
    98839879        p_vci_ixr.pktid   = 0;
    98849880        p_vci_ixr.cons    = false;
     
    99169912            p_vci_ixr.cmdval  = true;
    99179913            p_vci_ixr.address = (addr_t)r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2);
    9918             p_vci_ixr.wdata   = ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read()].read()) | 
     9914            p_vci_ixr.wdata   = ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read()].read()) |
    99199915                    ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read() + 1].read()) << 32));
    99209916            p_vci_ixr.trdid   = r_cleanup_to_ixr_cmd_index.read();
     
    99339929        if( (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ) or
    99349930                (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) )
    9935         { 
     9931        {
    99369932            p_vci_ixr.rspack = (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP);
    99379933        }
     
    1010910105                    p_vci_tgt.rspval  = true;
    1011010106
    10111                     if( is_ll and not r_tgt_rsp_key_sent.read() ) 
     10107                    if( is_ll and not r_tgt_rsp_key_sent.read() )
    1011210108                    {
    1011310109                        // LL response first flit
    1011410110                        p_vci_tgt.rdata = r_xram_rsp_to_tgt_rsp_ll_key.read();
    1011510111                    }
    10116                     else 
     10112                    else
    1011710113                    {
    1011810114                        // LL response second flit or READ response
     
    1027510271                            m_broadcast_boundaries,
    1027610272                            DspinRwtParam::BROADCAST_BOX);
    10277                    
     10273
    1027810274                    DspinRwtParam::dspin_set( flit,
    1027910275                            1,
Note: See TracChangeset for help on using the changeset viewer.