Context Navigation

← Previous Change
Next Change →

Changeset 440 for branches/v5/modules/vci_mem_cache/caba/source/include

Timestamp:

Jul 17, 2013, 9:24:48 AM (11 years ago)

Author:

cfuguet

Message:

Merging branch/v5/vci_mem_cache with trunk modifications to
start the development of new coherence protocol modifications
in this component

Location:

branches/v5/modules/vci_mem_cache

Files:

: 5 edited

. (modified) (1 prop)
caba/source/include/mem_cache_directory.h (modified) (8 diffs)
caba/source/include/update_tab.h (modified) (16 diffs)
caba/source/include/vci_mem_cache.h (modified) (30 diffs)
caba/source/include/xram_transaction.h (modified) (5 diffs)

Legend:

: Unmodified
: Added
: Removed

branches/v5/modules/vci_mem_cache
- Property svn:mergeinfo set to
  /trunk/modules/vci_mem_cache merged eligible

branches/v5/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

-                      r307
+                      r440
   ////////////////////////////////////////////////////////////////////////
   class Owner{
-    typedef uint32_t size_t;
     public:
 …
     typedef uint32_t tag_t;
-    typedef uint32_t size_t;
     public:
 …
     void print()
+    {
+      std::cout << "Valid = " << valid << " ; IS COUNT = " << is_cnt << " ; Dirty = " << dirty << " ; Lock = "
+                << lock
+      std::cout << "Valid = " << valid
+                << " ; IS COUNT = " << is_cnt
+                << " ; Dirty = " << dirty
+                << " ; Lock = " << lock
                 << " ; Tag = " << std::hex << tag << std::dec
                 << " ; Count = " << count
 …
     typedef uint32_t data_t;
     typedef uint32_t tag_t;
-    typedef uint32_t size_t;
     private:
 …
     /////////////////////////////////////////////////////////////////////
+    // The inval function invalidate an entry defined by the set and
+    // way arguments.
+    /////////////////////////////////////////////////////////////////////
+    void inval( const size_t &set, const size_t &way )
+    {
+        m_dir_tab[set][way].init();
+    }
+    /////////////////////////////////////////////////////////////////////
     // The read_neutral() function reads a directory entry, without
     // changing the LRU
 …
       // update LRU bits
       bool all_recent = true;
+      for ( size_t i=0 ; i<m_ways ; i++ ) {
+        if ( i != way ) all_recent = m_lru_tab[set][i].recent && all_recent;
+      }
+      if ( all_recent ) {
+        for( size_t i=0 ; i<m_ways ; i++ ) m_lru_tab[set][i].recent = false;
+      } else {
+        m_lru_tab[set][way].recent = true;
+      for ( size_t i=0 ; i<m_ways ; i++ )
+      {
+          if ( i != way ) all_recent = m_lru_tab[set][i].recent && all_recent;
+      }
+      if ( all_recent )
+      {
+          for( size_t i=0 ; i<m_ways ; i++ ) m_lru_tab[set][i].recent = false;
+      }
+      else
+      {
+          m_lru_tab[set][way].recent = true;
+      }
     } // end write()
 …
   ///////////////////////////////////////////////////////////////////////
   class HeapEntry{
-    typedef uint32_t size_t;
     public:
 …
   ////////////////////////////////////////////////////////////////////////
   class HeapDirectory{
-    typedef uint32_t size_t;
     private:

branches/v5/modules/vci_mem_cache/caba/source/include/update_tab.h

-                      r307
+                      r440
 ////////////////////////////////////////////////////////////////////////
 class UpdateTabEntry {
   typedef uint32_t size_t;
   typedef sc_dt::sc_uint<40> addr_t;
   public:
   bool      valid;      // It is a valid pending transaction
   bool      update;     // It is an update transaction
   bool      brdcast;    // It is a broadcast invalidate
+  bool      rsp;        // It needs a response to the initiator
+  bool      rsp;        // Response to the initiator required
+  bool      ack;        // Acknowledge to the CONFIG FSM required
   size_t        srcid;      // The srcid of the initiator which wrote the data
   size_t        trdid;      // The trdid of the initiator which wrote the data
 …
   size_t        count;      // The number of acknowledge responses to receive
+  UpdateTabEntry(){
+  UpdateTabEntry()
+  {
     valid       = false;
     update  = false;
     brdcast = false;
     rsp     = false;
+    ack     = false;
     srcid       = 0;
     trdid       = 0;
 …
   UpdateTabEntry(bool   i_valid,
+      bool   i_update,
+      bool   i_brdcast,
+      bool   i_rsp,
+      size_t i_srcid,
+      size_t i_trdid,
+      size_t i_pktid,
+      addr_t i_nline,
+      size_t i_count)
+                 bool   i_update,
+                 bool   i_brdcast,
+                 bool   i_rsp,
+                 bool   i_ack,
+                 size_t i_srcid,
+                 size_t i_trdid,
+                 size_t i_pktid,
+                 addr_t i_nline,
+                 size_t i_count)
+  {
     valid       = i_valid;
 …
     brdcast = i_brdcast;
     rsp     = i_rsp;
+    ack     = i_ack;
     srcid       = i_srcid;
     trdid       = i_trdid;
 …
     brdcast = source.brdcast;
     rsp     = source.rsp;
+    ack     = source.ack;
     srcid   = source.srcid;
     trdid   = source.trdid;
 …
     brdcast= false;
     rsp    = false;
+    ack    = false;
     srcid  = 0;
     trdid  = 0;
 …
     brdcast= source.brdcast;
     rsp    = source.rsp;
+    ack    = source.ack  ;
     srcid  = source.srcid;
     trdid  = source.trdid;
 …
   // The print() function prints the entry
   ////////////////////////////////////////////////////////////////////
+  void print(){
+    std::cout << std::dec << "valid  = " << valid  << std::endl;
+    std::cout << "update = " << update << std::endl;
+    std::cout << "brdcast= " << brdcast<< std::endl;
+    std::cout << "rsp    = " << rsp    << std::endl;
+    std::cout << "srcid  = " << srcid  << std::endl;
+    std::cout << "trdid  = " << trdid  << std::endl;
+    std::cout << "pktid  = " << pktid  << std::endl;
+    std::cout << std::hex << "nline  = " << nline  << std::endl;
+    std::cout << std::dec << "count  = " << count  << std::endl;
+  void print()
+  {
+    std::cout << " val = " << std::dec << valid
+              << " / updt = " << update
+              << " / bc = " << brdcast
+              << " / rsp = " << rsp
+              << " / ack = " << ack
+              << " / count = " << count
+              << " / srcid = " << std::hex << srcid
+              << " / trdid = " << trdid
+              << " / pktid = " << pktid
+              << " / nline = " << nline  << std::endl;
+  }
 };
 …
 class UpdateTab{
+  typedef uint32_t size_t;
+  typedef sc_dt::sc_uint<40> addr_t;
+  typedef uint64_t addr_t;
   private:
   size_t size_tab;
+  size_t                      size_tab;
   std::vector<UpdateTabEntry> tab;
 …
   // The size() function returns the size of the tab
   ////////////////////////////////////////////////////////////////////
+  const size_t size(){
+  const size_t size()
+  {
     return size_tab;
+  }
   ////////////////////////////////////////////////////////////////////
   // The print() function diplays the tab content
   ////////////////////////////////////////////////////////////////////
+  void print(){
+    for(size_t i=0; i<size_tab; i++) {
+      std::cout << "UPDATE TAB ENTRY " << std::dec << i << "--------" << std::endl;
+  void print()
+  {
+    std::cout << "UPDATE TABLE Content" << std::endl;
+    for(size_t i=0; i<size_tab; i++)
+    {
+      std::cout << "[" << std::dec << i << "] ";
       tab[i].print();
+    }
 …
+  }
   /////////////////////////////////////////////////////////////////////
   // The init() function initializes the tab
   /////////////////////////////////////////////////////////////////////
+  void init(){
+    for ( size_t i=0; i<size_tab; i++) {
+      tab[i].init();
+    }
+  }
+  void init()
+  {
+    for ( size_t i=0; i<size_tab; i++) tab[i].init();
+  }
   /////////////////////////////////////////////////////////////////////
 …
   ///////////////////////////////////////////////////////////////////////////
   bool set(const bool   update,
+      const bool   brdcast,
+      const bool   rsp,
+      const size_t srcid,
+      const size_t trdid,
+      const size_t pktid,
+      const addr_t nline,
+      const size_t count,
+      size_t &index)
+  {
+    for ( size_t i=0 ; i<size_tab ; i++ ) {
+      if( !tab[i].valid ) {
+           const bool   brdcast,
+           const bool   rsp,
+           const bool   ack,
+           const size_t srcid,
+           const size_t trdid,
+           const size_t pktid,
+           const addr_t nline,
+           const size_t count,
+           size_t       &index)
+  {
+    for ( size_t i=0 ; i<size_tab ; i++ )
+    {
+      if( !tab[i].valid )
+      {
         tab[i].valid            = true;
         tab[i].update           = update;
         tab[i].brdcast      = brdcast;
         tab[i].rsp          = rsp;
+        tab[i].ack          = ack;
         tab[i].srcid            = (size_t) srcid;
         tab[i].trdid            = (size_t) trdid;
 …
   /////////////////////////////////////////////////////////////////////
   bool decrement( const size_t index,
       size_t &counter )
+                  size_t &counter )
+  {
     assert((index<size_tab) && "Bad Update Tab Entry");
+    if ( tab[index].valid ) {
+    if ( tab[index].valid )
+    {
       tab[index].count--;
       counter = tab[index].count;
       return true;
+    } else {
+    }
+    else
+    {
       return false;
+    }
 …
   bool is_full()
+  {
+    for(size_t i = 0 ; i < size_tab ; i++){
+      if(!tab[i].valid){
+        return false;
+      }
+    for(size_t i = 0 ; i < size_tab ; i++)
+    {
+      if(!tab[i].valid) return false;
+    }
     return true;
 …
   bool is_not_empty()
+  {
+    for(size_t i = 0 ; i < size_tab ; i++){
+      if(tab[i].valid){
+    for(size_t i = 0 ; i < size_tab ; i++)
+    {
+      if(tab[i].valid) return true;
+    }
+    return false;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The need_rsp() function returns the need of a response
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool need_rsp(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].rsp;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The need_ack() function returns the need of an acknowledge
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool need_ack(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].ack;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The is_brdcast() function returns the transaction type
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool is_brdcast(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].brdcast;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The is_update() function returns the transaction type
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool is_update(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].update;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The srcid() function returns the srcid value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  size_t srcid(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].srcid;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The trdid() function returns the trdid value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  size_t trdid(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].trdid;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The pktid() function returns the pktid value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  size_t pktid(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].pktid;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The nline() function returns the nline value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  addr_t nline(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].nline;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The search_inval() function returns the index of the entry in UPT
+  // Arguments :
+  // - nline : the line number of the entry in the directory
+  /////////////////////////////////////////////////////////////////////
+  bool search_inval(const addr_t nline,size_t &index)
+  {
+    size_t i ;
+    for (i = 0 ; i < size_tab ; i++)
+    {
+      if ( (tab[i].nline == nline) and tab[i].valid and not tab[i].update )
+      {
+        index = i ;
         return true;
+      }
 …
   /////////////////////////////////////////////////////////////////////
+  // The need_rsp() function returns the need of a response
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool need_rsp(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].rsp;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The is_update() function returns the transaction type
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool is_brdcast(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].brdcast;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The is_update() function returns the transaction type
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  bool is_update(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].update;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The srcid() function returns the srcid value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  size_t srcid(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].srcid;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The trdid() function returns the trdid value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  size_t trdid(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].trdid;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The pktid() function returns the pktid value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  size_t pktid(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].pktid;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The nline() function returns the nline value
+  // Arguments :
+  // - index : the index of the entry
+  /////////////////////////////////////////////////////////////////////
+  addr_t nline(const size_t index)
+  {
+    assert(index<size_tab && "Bad Update Tab Entry");
+    return tab[index].nline;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The search_inval() function returns the index of the entry in UPT
+  // The read_nline() function returns the index of the entry in UPT
   // Arguments :
   // - nline : the line number of the entry in the directory
   /////////////////////////////////////////////////////////////////////
   bool search_inval(const addr_t nline,size_t &index)
+  bool read_nline(const addr_t nline,size_t &index)
+  {
     size_t i ;
+    for (i = 0 ; i < size_tab ; i++){
+      if((tab[i].nline == nline) && tab[i].valid){
+        if(!tab[i].update){
+          index = i ;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /////////////////////////////////////////////////////////////////////
+  // The read_nline() function returns the index of the entry in UPT
+  // Arguments :
+  // - nline : the line number of the entry in the directory
+  /////////////////////////////////////////////////////////////////////
+  bool read_nline(const addr_t nline,size_t &index)
+  {
+    size_t i ;
+    for (i = 0 ; i < size_tab ; i++){
+      if((tab[i].nline == nline) && tab[i].valid){
+    for (i = 0 ; i < size_tab ; i++)
+    {
+      if ( (tab[i].nline == nline) and tab[i].valid )
+      {
         index = i ;
         return true;

branches/v5/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

-                      r362
+                      r440
 #include "dspin_dhccp_param.h"
+#define TRANSACTION_TAB_LINES 4 // Number of lines in the transaction tab
+#define UPDATE_TAB_LINES      4 // Number of lines in the update tab
+#define TRT_ENTRIES      4      // Number of entries in TRT
+#define UPT_ENTRIES      4      // Number of entries in UPT
+#define HEAP_ENTRIES     1024   // Number of entries in HEAP
 namespace soclib {  namespace caba {
   using namespace sc_core;
+  template<typename vci_param>
+  template<typename vci_param_int,
+           typename vci_param_ext,
+           size_t   dspin_in_width,
+           size_t   dspin_out_width>
     class VciMemCache
     : public soclib::caba::BaseModule
+    {
+      typedef sc_dt::sc_uint<40> addr_t;
+      typedef typename vci_param::fast_addr_t vci_addr_t;
+      typedef typename vci_param_int::fast_addr_t  addr_t;
+      typedef typename sc_dt::sc_uint<64>          wide_data_t;
       typedef uint32_t data_t;
       typedef uint32_t tag_t;
-      typedef uint32_t size_t;
       typedef uint32_t be_t;
       typedef uint32_t copy_t;
       /* States of the TGT_CMD fsm */
+      enum tgt_cmd_fsm_state_e{
+      enum tgt_cmd_fsm_state_e
+      {
         TGT_CMD_IDLE,
+        TGT_CMD_ERROR,
         TGT_CMD_READ,
         TGT_CMD_WRITE,
+        TGT_CMD_CAS
+        TGT_CMD_CAS,
+        TGT_CMD_CONFIG
       };
       /* States of the TGT_RSP fsm */
+      enum tgt_rsp_fsm_state_e{
+      enum tgt_rsp_fsm_state_e
+      {
+        TGT_RSP_CONFIG_IDLE,
+        TGT_RSP_TGT_CMD_IDLE,
         TGT_RSP_READ_IDLE,
         TGT_RSP_WRITE_IDLE,
         TGT_RSP_CAS_IDLE,
         TGT_RSP_XRAM_IDLE,
         TGT_RSP_INIT_IDLE,
+        TGT_RSP_MULTI_ACK_IDLE,
         TGT_RSP_CLEANUP_IDLE,
+        TGT_RSP_CONFIG,
+        TGT_RSP_TGT_CMD,
         TGT_RSP_READ,
         TGT_RSP_WRITE,
         TGT_RSP_CAS,
         TGT_RSP_XRAM,
         TGT_RSP_INIT,
+        TGT_RSP_MULTI_ACK,
         TGT_RSP_CLEANUP
       };
       /* States of the DSPIN_TGT fsm */
+      enum cc_receive_fsm_state_e{
+      enum cc_receive_fsm_state_e
+      {
         CC_RECEIVE_IDLE,
         CC_RECEIVE_CLEANUP,
+        CC_RECEIVE_CLEANUP_EOP,
         CC_RECEIVE_MULTI_ACK
       };
       /* States of the CC_SEND fsm */
+      enum cc_send_fsm_state_e{
+      enum cc_send_fsm_state_e
+      {
+        CC_SEND_CONFIG_IDLE,
         CC_SEND_XRAM_RSP_IDLE,
         CC_SEND_WRITE_IDLE,
         CC_SEND_CAS_IDLE,
         CC_SEND_CLEANUP_IDLE,
+        CC_SEND_CONFIG_INVAL_HEADER,
+        CC_SEND_CONFIG_INVAL_NLINE,
+        CC_SEND_CONFIG_BRDCAST_HEADER,
+        CC_SEND_CONFIG_BRDCAST_NLINE,
         CC_SEND_CLEANUP_ACK,
         CC_SEND_XRAM_RSP_BRDCAST_HEADER,
 …
       /* States of the MULTI_ACK fsm */
+      enum multi_ack_fsm_state_e{
+      enum multi_ack_fsm_state_e
+      {
         MULTI_ACK_IDLE,
         MULTI_ACK_UPT_LOCK,
         MULTI_ACK_UPT_CLEAR,
+        MULTI_ACK_WRITE_RSP
+        MULTI_ACK_WRITE_RSP,
+        MULTI_ACK_CONFIG_ACK
+      };
+      /* States of the CONFIG fsm */
+      enum config_fsm_state_e
+      {
+        CONFIG_IDLE,
+        CONFIG_LOOP,
+        CONFIG_RSP,
+        CONFIG_DIR_REQ,
+        CONFIG_DIR_ACCESS,
+        CONFIG_DIR_UPT_LOCK,
+        CONFIG_BC_SEND,
+        CONFIG_BC_WAIT,
+        CONFIG_INV_SEND,
+        CONFIG_HEAP_REQ,
+        CONFIG_HEAP_SCAN,
+        CONFIG_HEAP_LAST,
+        CONFIG_INV_WAIT
       };
       /* States of the READ fsm */
+      enum read_fsm_state_e{
+      enum read_fsm_state_e
+      {
         READ_IDLE,
         READ_DIR_REQ,
 …
       /* States of the WRITE fsm */
+      enum write_fsm_state_e{
+      enum write_fsm_state_e
+      {
         WRITE_IDLE,
         WRITE_NEXT,
 …
       /* States of the IXR_RSP fsm */
+      enum ixr_rsp_fsm_state_e{
+      enum ixr_rsp_fsm_state_e
+      {
         IXR_RSP_IDLE,
         IXR_RSP_ACK,
 …
       /* States of the XRAM_RSP fsm */
+      enum xram_rsp_fsm_state_e{
+      enum xram_rsp_fsm_state_e
+      {
         XRAM_RSP_IDLE,
         XRAM_RSP_TRT_COPY,
 …
       /* States of the IXR_CMD fsm */
+      enum ixr_cmd_fsm_state_e{
+      enum ixr_cmd_fsm_state_e
+      {
         IXR_CMD_READ_IDLE,
         IXR_CMD_WRITE_IDLE,
         IXR_CMD_CAS_IDLE,
         IXR_CMD_XRAM_IDLE,
         IXR_CMD_READ_NLINE,
         IXR_CMD_WRITE_NLINE,
         IXR_CMD_CAS_NLINE,
         IXR_CMD_XRAM_DATA
+        IXR_CMD_READ,
+        IXR_CMD_WRITE,
+        IXR_CMD_CAS,
+        IXR_CMD_XRAM
       };
       /* States of the CAS fsm */
+      enum cas_fsm_state_e{
+      enum cas_fsm_state_e
+      {
         CAS_IDLE,
         CAS_DIR_REQ,
 …
       /* States of the CLEANUP fsm */
+      enum cleanup_fsm_state_e{
+      enum cleanup_fsm_state_e
+      {
         CLEANUP_IDLE,
         CLEANUP_GET_NLINE,
 …
         CLEANUP_UPT_CLEAR,
         CLEANUP_WRITE_RSP,
+        CLEANUP_SEND_ACK
+        CLEANUP_CONFIG_ACK,
+        CLEANUP_SEND_CLACK
       };
       /* States of the ALLOC_DIR fsm */
+      enum alloc_dir_fsm_state_e{
+      enum alloc_dir_fsm_state_e
+      {
         ALLOC_DIR_RESET,
+        ALLOC_DIR_CONFIG,
         ALLOC_DIR_READ,
         ALLOC_DIR_WRITE,
 …
       /* States of the ALLOC_TRT fsm */
+      enum alloc_trt_fsm_state_e{
+      enum alloc_trt_fsm_state_e
+      {
         ALLOC_TRT_READ,
         ALLOC_TRT_WRITE,
 …
       /* States of the ALLOC_UPT fsm */
+      enum alloc_upt_fsm_state_e{
+      enum alloc_upt_fsm_state_e
+      {
+        ALLOC_UPT_CONFIG,
         ALLOC_UPT_WRITE,
         ALLOC_UPT_XRAM_RSP,
 …
       /* States of the ALLOC_HEAP fsm */
+      enum alloc_heap_fsm_state_e{
+      enum alloc_heap_fsm_state_e
+      {
         ALLOC_HEAP_RESET,
         ALLOC_HEAP_READ,
 …
         ALLOC_HEAP_CAS,
         ALLOC_HEAP_CLEANUP,
+        ALLOC_HEAP_XRAM_RSP
+        ALLOC_HEAP_XRAM_RSP,
+        ALLOC_HEAP_CONFIG
       };
 …
       };
+      /* Configuration commands */
+      enum cmd_config_type_e
+      {
+          CMD_CONFIG_INVAL = 0,
+          CMD_CONFIG_SYNC  = 1
+      };
       // debug variables (for each FSM)
+      bool         m_debug_global;
+      bool         m_debug_tgt_cmd_fsm;
+      bool         m_debug_tgt_rsp_fsm;
+      bool         m_debug_cc_send_fsm;
+      bool         m_debug_cc_receive_fsm;
+      bool         m_debug_multi_ack_fsm;
+      bool         m_debug_read_fsm;
+      bool         m_debug_write_fsm;
+      bool         m_debug_cas_fsm;
+      bool         m_debug_cleanup_fsm;
+      bool         m_debug_ixr_cmd_fsm;
+      bool         m_debug_ixr_rsp_fsm;
+      bool         m_debug_xram_rsp_fsm;
+      bool         m_debug;
       bool         m_debug_previous_hit;
       size_t       m_debug_previous_count;
       bool         m_monitor_ok;
       vci_addr_t   m_monitor_base;
       vci_addr_t   m_monitor_length;
+      addr_t       m_monitor_base;
+      addr_t       m_monitor_length;
       // instrumentation counters
       uint32_t     m_cpt_cycles;        // Counter of cycles
       uint32_t     m_cpt_read;          // Number of READ transactions
+      uint32_t     m_cpt_read_remote;   // number of remote READ transactions
+      uint32_t     m_cpt_read_flits;    // number of flits for READs
+      uint32_t     m_cpt_read_cost;     // Number of (flits * distance) for READs
       uint32_t     m_cpt_read_miss;     // Number of MISS READ
       uint32_t     m_cpt_write;         // Number of WRITE transactions
+      uint32_t     m_cpt_write_remote;  // number of remote WRITE transactions
+      uint32_t     m_cpt_write_flits;   // number of flits for WRITEs
+      uint32_t     m_cpt_write_cost;    // Number of (flits * distance) for WRITEs
       uint32_t     m_cpt_write_miss;    // Number of MISS WRITE
       uint32_t     m_cpt_write_cells;   // Cumulated length for WRITE transactions
 …
       uint32_t     m_cpt_cas;           // Number of CAS transactions
+      uint32_t     m_cpt_cleanup_cost;  // Number of (flits * distance) for CLEANUPs
+      uint32_t     m_cpt_update_flits;  // Number of flits for UPDATEs
+      uint32_t     m_cpt_update_cost;   // Number of (flits * distance) for UPDATEs
+      uint32_t     m_cpt_inval_cost;    // Number of (flits * distance) for INVALs
+      uint32_t     m_cpt_get;
+      uint32_t     m_cpt_put;
       size_t       m_prev_count;
 …
       public:
       sc_in<bool>                           p_clk;
       sc_in<bool>                           p_resetn;
       soclib::caba::VciTarget<vci_param>    p_vci_tgt;
       soclib::caba::VciInitiator<vci_param> p_vci_ixr;
       soclib::caba::DspinInput<33>          p_dspin_in;
       soclib::caba::DspinOutput<40>         p_dspin_out;
+      sc_in<bool>                                 p_clk;
+      sc_in<bool>                                 p_resetn;
+      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
+      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
+      soclib::caba::DspinInput<dspin_in_width>    p_dspin_in;
+      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_out;
       VciMemCache(
           sc_module_name name,                                // Instance Name
           const soclib::common::MappingTable &mtp,            // Mapping table for direct network
           const soclib::common::MappingTable &mtx,            // Mapping table for external network
           const soclib::common::IntTab       &srcid_x,        // global index on external network
           const soclib::common::IntTab       &tgtid_d,        // global index on direct network
           const size_t                       cc_global_id,    // global index on cc network
+          const soclib::common::MappingTable &mtp,            // Mapping table INT network
+          const soclib::common::MappingTable &mtx,            // Mapping table RAM network
+          const soclib::common::IntTab       &srcid_x,        // global index RAM network
+          const soclib::common::IntTab       &tgtid_d,        // global index INT network
+          const size_t                       cc_global_id,    // global index CC network
           const size_t                       nways,           // Number of ways per set
           const size_t                       nsets,           // Number of sets
           const size_t                       nwords,          // Number of words per line
           const size_t                       max_copies,      // max number of copies in heap
           const size_t                       heap_size=1024,  // number of heap entries
           const size_t                       trt_lines=TRANSACTION_TAB_LINES,
           const size_t                       upt_lines=UPDATE_TAB_LINES,
+          const size_t                       max_copies,      // max number of copies
+          const size_t                       heap_size=HEAP_ENTRIES,
+          const size_t                       trt_lines=TRT_ENTRIES,
+          const size_t                       upt_lines=UPT_ENTRIES,
           const size_t                       debug_start_cycle=0,
           const bool                         debug_ok=false );
 …
       void print_stats();
       void print_trace();
       void copies_monitor(vci_addr_t addr);
       void start_monitor(vci_addr_t addr, vci_addr_t length);
+      void copies_monitor(addr_t addr);
+      void start_monitor(addr_t addr, addr_t length);
       void stop_monitor();
 …
       void transition();
       void genMoore();
+      void check_monitor( const char *buf, vci_addr_t addr, data_t data);
+      void check_monitor_read( const char *buf, vci_addr_t addr);
+      void check_monitor( const char *buf, addr_t addr, data_t data, bool read);
       // Component attributes
       std::list<soclib::common::Segment> m_seglist;          // segments allocated to memcache
+      std::list<soclib::common::Segment> m_seglist;          // segments allocated
       size_t                             m_nseg;             // number of segments
       soclib::common::Segment            **m_seg;            // array of segments pointers
+      const size_t                       m_srcid_x;          // global index on external network
+      size_t                             m_seg_config;       // config segment index
+      const size_t                       m_srcid_x;          // global index on RAM network
       const size_t                       m_initiators;       // Number of initiators
       const size_t                       m_heap_size;        // Size of the heap
 …
       size_t                             m_max_copies;       // max number of copies in heap
       GenericLLSCGlobalTable
+      < 32  ,                              // number of slots
+,                              // number of processors in the system
+,                              // registratioÃ§n life span (in # of LL operations)
+        typename vci_param::fast_addr_t >  // address type
+                                         m_llsc_table;       // ll/sc global registration table
+      < 32  ,    // number of slots
+,    // number of processors in the system
+,    // registration life (# of LL operations)
+        addr_t >                         m_llsc_table;       // ll/sc registration table
       // adress masks
       const soclib::common::AddressMaskingTable<vci_addr_t>   m_x;
       const soclib::common::AddressMaskingTable<vci_addr_t>   m_y;
       const soclib::common::AddressMaskingTable<vci_addr_t>   m_z;
       const soclib::common::AddressMaskingTable<vci_addr_t>   m_nline;
+      const soclib::common::AddressMaskingTable<addr_t>   m_x;
+      const soclib::common::AddressMaskingTable<addr_t>   m_y;
+      const soclib::common::AddressMaskingTable<addr_t>   m_z;
+      const soclib::common::AddressMaskingTable<addr_t>   m_nline;
       // broadcast address
       uint32_t                                                m_broadcast_address;
+      uint32_t                           m_broadcast_boundaries;
       //////////////////////////////////////////////////
 …
       //////////////////////////////////////////////////
+      sc_signal<int>         r_tgt_cmd_fsm;
       // Fifo between TGT_CMD fsm and READ fsm
       GenericFifo<uint64_t>  m_cmd_read_addr_fifo;
+      GenericFifo<addr_t>    m_cmd_read_addr_fifo;
       GenericFifo<size_t>    m_cmd_read_length_fifo;
       GenericFifo<size_t>    m_cmd_read_srcid_fifo;
 …
       // Fifo between TGT_CMD fsm and WRITE fsm
       GenericFifo<uint64_t>  m_cmd_write_addr_fifo;
+      GenericFifo<addr_t>    m_cmd_write_addr_fifo;
       GenericFifo<bool>      m_cmd_write_eop_fifo;
       GenericFifo<size_t>    m_cmd_write_srcid_fifo;
 …
       // Fifo between TGT_CMD fsm and CAS fsm
       GenericFifo<uint64_t>  m_cmd_cas_addr_fifo;
+      GenericFifo<addr_t>    m_cmd_cas_addr_fifo;
       GenericFifo<bool>      m_cmd_cas_eop_fifo;
       GenericFifo<size_t>    m_cmd_cas_srcid_fifo;
 …
       GenericFifo<data_t>    m_cmd_cas_wdata_fifo;
       // Fifo between INIT_RSP fsm and CLEANUP fsm
+      // Fifo between CC_RECEIVE fsm and CLEANUP fsm
       GenericFifo<uint64_t>  m_cc_receive_to_cleanup_fifo;
       // Fifo between INIT_RSP fsm and MULTI_ACK fsm
+      // Fifo between CC_RECEIVE fsm and MULTI_ACK fsm
       GenericFifo<uint64_t>  m_cc_receive_to_multi_ack_fifo;
+      sc_signal<int>         r_tgt_cmd_fsm;
+      // Buffer between TGT_CMD fsm and TGT_RSP fsm
+      // (segmentation violation response request)
+      sc_signal<bool>     r_tgt_cmd_to_tgt_rsp_req;
+      sc_signal<uint32_t> r_tgt_cmd_to_tgt_rsp_rdata;
+      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_error;
+      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_srcid;
+      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_trdid;
+      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_pktid;
+      sc_signal<addr_t>   r_tgt_cmd_config_addr;
+      sc_signal<size_t>   r_tgt_cmd_config_cmd;
+      ///////////////////////////////////////////////////////
+      // Registers controlled by the CONFIG fsm
+      ///////////////////////////////////////////////////////
+      sc_signal<int>      r_config_fsm;            // FSM state
+      sc_signal<bool>     r_config_lock;           // lock protecting exclusive access
+      sc_signal<int>      r_config_cmd;            // config request status
+      sc_signal<addr_t>   r_config_address;        // target buffer physical address
+      sc_signal<size_t>   r_config_srcid;          // config request srcid
+      sc_signal<size_t>   r_config_trdid;          // config request trdid
+      sc_signal<size_t>   r_config_pktid;          // config request pktid
+      sc_signal<size_t>   r_config_nlines;         // number of lines covering the buffer
+      sc_signal<size_t>   r_config_dir_way;        // DIR: selected way
+      sc_signal<size_t>   r_config_dir_count;      // DIR: number of copies
+      sc_signal<bool>     r_config_dir_is_cnt;     // DIR: counter mode (broadcast required)
+      sc_signal<size_t>   r_config_dir_copy_srcid; // DIR: first copy SRCID
+      sc_signal<bool>     r_config_dir_copy_inst;  // DIR: first copy L1 type
+      sc_signal<size_t>   r_config_dir_next_ptr;   // DIR: index of next copy in HEAP
+      sc_signal<size_t>   r_config_heap_next;      // current pointer to scan HEAP
+      sc_signal<size_t>   r_config_upt_index;  // UPT index
+      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
+      sc_signal<bool>     r_config_to_tgt_rsp_req;    // valid request
+      sc_signal<bool>     r_config_to_tgt_rsp_error;  // error response
+      sc_signal<size_t>   r_config_to_tgt_rsp_srcid;  // Transaction srcid
+      sc_signal<size_t>   r_config_to_tgt_rsp_trdid;  // Transaction trdid
+      sc_signal<size_t>   r_config_to_tgt_rsp_pktid;  // Transaction pktid
+      // Buffer between CONFIG fsm and CC_SEND fsm (multi-inval / broadcast-inval)
+      sc_signal<bool>     r_config_to_cc_send_multi_req;    // multi-inval request
+      sc_signal<bool>     r_config_to_cc_send_brdcast_req;  // broadcast-inval request
+      sc_signal<addr_t>   r_config_to_cc_send_nline;        // line index
+      sc_signal<size_t>   r_config_to_cc_send_trdid;        // UPT index
+      GenericFifo<bool>   m_config_to_cc_send_inst_fifo;    // fifo for the L1 type
+      GenericFifo<size_t> m_config_to_cc_send_srcid_fifo;   // fifo for owners srcid
+#if L1_MULTI_CACHE
+      GenericFifo<size_t> m_config_to_cc_send_cache_id_fifo; // fifo for cache_id
+#endif
       ///////////////////////////////////////////////////////
 …
       ///////////////////////////////////////////////////////
+      sc_signal<int>      r_read_fsm;        // FSM state
+      sc_signal<size_t>   r_read_copy;       // Srcid of the first copy
+      sc_signal<size_t>   r_read_copy_cache; // Srcid of the first copy
+      sc_signal<bool>     r_read_copy_inst;  // Type of the first copy
+      sc_signal<tag_t>    r_read_tag;        // cache line tag (in directory)
+      sc_signal<bool>     r_read_is_cnt;     // is_cnt bit (in directory)
+      sc_signal<bool>     r_read_lock;       // lock bit (in directory)
+      sc_signal<bool>     r_read_dirty;      // dirty bit (in directory)
+      sc_signal<size_t>   r_read_count;      // number of copies
+      sc_signal<size_t>   r_read_ptr;        // pointer to the heap
+      sc_signal<data_t> * r_read_data;       // data (one cache line)
+      sc_signal<size_t>   r_read_way;        // associative way (in cache)
+      sc_signal<size_t>   r_read_trt_index;  // Transaction Table index
+      sc_signal<size_t>   r_read_next_ptr;   // Next entry to point to
+      sc_signal<bool>     r_read_last_free;  // Last free entry
+      sc_signal<typename vci_param::fast_addr_t>
+                          r_read_ll_key;     // LL key returned by the llsc_global_table
+      sc_signal<int>      r_read_fsm;          // FSM state
+      sc_signal<size_t>   r_read_copy;         // Srcid of the first copy
+      sc_signal<size_t>   r_read_copy_cache;   // Srcid of the first copy
+      sc_signal<bool>     r_read_copy_inst;    // Type of the first copy
+      sc_signal<tag_t>    r_read_tag;          // cache line tag (in directory)
+      sc_signal<bool>     r_read_is_cnt;       // is_cnt bit (in directory)
+      sc_signal<bool>     r_read_lock;         // lock bit (in directory)
+      sc_signal<bool>     r_read_dirty;        // dirty bit (in directory)
+      sc_signal<size_t>   r_read_count;        // number of copies
+      sc_signal<size_t>   r_read_ptr;          // pointer to the heap
+      sc_signal<data_t> * r_read_data;         // data (one cache line)
+      sc_signal<size_t>   r_read_way;          // associative way (in cache)
+      sc_signal<size_t>   r_read_trt_index;    // Transaction Table index
+      sc_signal<size_t>   r_read_next_ptr;     // Next entry to point to
+      sc_signal<bool>     r_read_last_free;    // Last free entry
+      sc_signal<addr_t>   r_read_ll_key;       // LL key from the llsc_global_table
       // Buffer between READ fsm and IXR_CMD fsm (ask a missing cache line to XRAM)
 …
       sc_signal<size_t>   r_read_to_tgt_rsp_word;   // first word of the response
       sc_signal<size_t>   r_read_to_tgt_rsp_length; // length of the response
+      sc_signal<typename vci_param::fast_addr_t>
+                          r_read_to_tgt_rsp_ll_key; // LL key returned by the llsc_global_table
+      sc_signal<addr_t>   r_read_to_tgt_rsp_ll_key; // LL key from the llsc_global_table
       ///////////////////////////////////////////////////////////////
 …
       GenericFifo<bool>   m_write_to_cc_send_inst_fifo;     // fifo for the L1 type
       GenericFifo<size_t> m_write_to_cc_send_srcid_fifo;    // fifo for srcids
 #if L1_MULTI_CACHE
       GenericFifo<size_t> m_write_to_cc_send_cache_id_fifo; // fifo for srcids
 …
       sc_signal<size_t>   r_multi_ack_pktid;     // pending write pktid
       sc_signal<addr_t>   r_multi_ack_nline;     // pending write nline
+      // signaling completion of multi-inval to CONFIG fsm
+      sc_signal<bool>     r_multi_ack_to_config_ack;
       // Buffer between MULTI_ACK fsm and TGT_RSP fsm (complete write/update transaction)
 …
       sc_signal<size_t>   r_cleanup_way;           // associative way (in cache)
       sc_signal<size_t>   r_cleanup_write_srcid;   // srcid of write response
+      sc_signal<size_t>   r_cleanup_write_srcid;   // srcid of write rsp
       sc_signal<size_t>   r_cleanup_write_trdid;   // trdid of write rsp
       sc_signal<size_t>   r_cleanup_write_pktid;   // pktid of write rsp
+      sc_signal<bool>     r_cleanup_write_need_rsp;// needs a write rsp
+      sc_signal<bool>     r_cleanup_need_rsp;      // write response required
+      sc_signal<bool>     r_cleanup_need_ack;      // config acknowledge required
       sc_signal<size_t>   r_cleanup_index;         // index of the INVAL line (in the UPT)
+      // signaling completion of broadcast-inval to CONFIG fsm
+      sc_signal<bool>     r_cleanup_to_config_ack;
       // Buffer between CLEANUP fsm and TGT_RSP fsm (acknowledge a write command from L1)
       sc_signal<bool>     r_cleanup_to_tgt_rsp_req;   // valid request
 …
       GenericFifo<bool>   m_cas_to_cc_send_inst_fifo;     // fifo for the L1 type
       GenericFifo<size_t> m_cas_to_cc_send_srcid_fifo;    // fifo for srcids
 #if L1_MULTI_CACHE
       GenericFifo<size_t> m_cas_to_cc_send_cache_id_fifo; // fifo for srcids
 …
       sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_length; // length of the response
       sc_signal<bool>     r_xram_rsp_to_tgt_rsp_rerror; // send error to requester
+      sc_signal<typename vci_param::fast_addr_t>
+                          r_xram_rsp_to_tgt_rsp_ll_key; // LL key returned by the llsc_global_table
+      sc_signal<addr_t>   r_xram_rsp_to_tgt_rsp_ll_key; // LL key from llsc_global_table
       // Buffer between XRAM_RSP fsm and CC_SEND fsm (Inval L1 Caches)
 …
       GenericFifo<bool>   m_xram_rsp_to_cc_send_inst_fifo;     // fifo for the L1 type
       GenericFifo<size_t> m_xram_rsp_to_cc_send_srcid_fifo;    // fifo for srcids
 #if L1_MULTI_CACHE
       GenericFifo<size_t> m_xram_rsp_to_cc_send_cache_id_fifo; // fifo for srcids

branches/v5/modules/vci_mem_cache/caba/source/include/xram_transaction.h

-                      r362
+                      r440
 ////////////////////////////////////////////////////////////////////////
+class TransactionTabEntry {
+    typedef uint32_t              size_t;
+class TransactionTabEntry
+{
+    typedef sc_dt::sc_uint<64>    wide_data_t;
+    typedef sc_dt::sc_uint<40>    addr_t;
     typedef uint32_t              data_t;
-    typedef sc_dt::sc_uint<40>    addr_t;
     typedef uint32_t              be_t;
 …
     // The print() function prints the entry
     ////////////////////////////////////////////////////////////////////
+    void print(){
+    void print()
+    {
         std::cout << "valid       = " << valid        << std::endl;
         std::cout << "xram_read   = " << xram_read    << std::endl;
 …
 //                  The transaction tab
 ////////////////////////////////////////////////////////////////////////
+class TransactionTab{
+    typedef uint32_t size_t;
+    typedef uint32_t data_t;
+    typedef sc_dt::sc_uint<40> addr_t;
+    typedef uint32_t be_t;
+class TransactionTab
+{
+    typedef sc_dt::sc_uint<64>    wide_data_t;
+    typedef sc_dt::sc_uint<40>    addr_t;
+    typedef uint32_t              data_t;
+    typedef uint32_t              be_t;
     private:
+    size_t size_tab;                // The size of the tab
+    const std::string tab_name;                // the name for logs
+    size_t            size_tab;                // the size of the tab
     data_t be_to_mask(be_t be)
 …
+    }
+    TransactionTab(size_t n_entries, size_t n_words)
+    {
+        size_tab = n_entries;
+    TransactionTab(const std::string &name,
+                   size_t            n_entries,
+                   size_t            n_words )
+    : tab_name( name ),
+      size_tab( n_entries )
+    {
         tab = new TransactionTabEntry[size_tab];
+        for ( size_t i=0; i<size_tab; i++) {
+        for ( size_t i=0; i<size_tab; i++)
+        {
             tab[i].alloc(n_words);
+        }
 …
     /////////////////////////////////////////////////////////////////////
     // The write_rsp() function writes a word of the response to an
     // XRAM read transaction.
+    // The write_rsp() function writes two 32 bits words of the response
+    // to a XRAM read transaction.
     // The BE field in TRT is taken into account.
     // Arguments :
     // - index : the index of the transaction in the transaction tab
     // - word_index : the index of the data in the line
     // - data : the data to write
+    // - data : a 64 bits value
     // - error : invalid data
     /////////////////////////////////////////////////////////////////////
+    void write_rsp(const size_t index,
+            const size_t word,
+            const data_t data,
+            const bool   rerror)
+    {
+        assert( (index < size_tab)
+                && "Selected entry  out of range in write_rsp() Transaction Tab");
+        assert( (word <= tab[index].wdata_be.size())
+                && "Bad word_index in write_rsp() in TransactionTab");
+        assert( tab[index].valid
+                && "Transaction Tab Entry invalid in write_rsp()");
+        assert( tab[index].xram_read
+                && "Selected entry is not an XRAM read transaction in write_rsp()");
+        data_t mask = be_to_mask(tab[index].wdata_be[word]);
+        tab[index].wdata[word] = (tab[index].wdata[word] & mask) | (data & ~mask);
+    void write_rsp(const size_t      index,
+                   const size_t      word,
+                   const wide_data_t data,
+                   const bool        rerror)
+    {
+        data_t  value;
+        data_t  mask;
+        if ( index >= size_tab )
+        {
+            std::cout << "VCI_MEM_CACHE ERRROR " << tab_name
+                      <<  " TRT entry  out of range in write_rsp()" << std::endl;
+            exit(0);
+        }
+        if ( word > tab[index].wdata_be.size() )
+        {
+            std::cout << "VCI_MEM_CACHE ERRROR " << tab_name
+                      <<  " Bad word_index in write_rsp() in TRT" << std::endl;
+            exit(0);
+        }
+        if ( not tab[index].valid )
+        {
+            std::cout << "VCI_MEM_CACHE ERRROR " << tab_name
+                      <<  " TRT Entry invalid in write_rsp()" << std::endl;
+            exit(0);
+        }
+        if ( not tab[index].xram_read )
+        {
+            std::cout << "VCI_MEM_CACHE ERRROR " << tab_name
+                      <<  " TRT entry is not an XRAM GET in write_rsp()" << std::endl;
+            exit(0);
+        }
+        // first 32 bits word
+        value = (data_t)data;
+        mask  = be_to_mask(tab[index].wdata_be[word]);
+        tab[index].wdata[word] = (tab[index].wdata[word] & mask) | (value & ~mask);
+        // second 32 bits word
+        value = (data_t)(data>>32);
+        mask  = be_to_mask(tab[index].wdata_be[word+1]);
+        tab[index].wdata[word+1] = (tab[index].wdata[word+1] & mask) | (value & ~mask);
+        // error update
         tab[index].rerror |= rerror;
+    }

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats:

Project-Id-Version: Trac 0.12
Report-Msgid-Bugs-To: trac-dev@googlegroups.com
POT-Creation-Date: 2018-07-07 16:55+0000
PO-Revision-Date: 2010-07-19 23:05+0200
Last-Translator: Jeroen Ruigrok van der Werven <asmodai@in-nomine.org>
Language: en_US
Language-Team: en_US <trac-dev@googlegroups.com>
Plural-Forms: nplurals=2; plural=(n != 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Generated-By: Babel 2.8.0