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

RWT commit : Cosmetic (Remove trailing whitespace)

Location:
branches/RWT/modules/vci_mem_cache
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • 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    /////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.