Changeset 434 for trunk/modules/vci_mem_cache/caba/source/include

Timestamp:

Jul 12, 2013, 12:16:30 PM (11 years ago)

Author:

alain

Message:

Introducing a preliminary configuration interface in vci_mem_cache.

Location:

trunk/modules/vci_mem_cache/caba/source/include

Files:

• mem_cache_directory.h (modified) (2 diffs)
• update_tab.h (modified) (16 diffs)
• vci_mem_cache.h (modified) (14 diffs)

trunk/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

@@ -274 +274 @@
 
     /////////////////////////////////////////////////////////////////////
+    // 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
@@ -320 +329 @@
       // 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()

trunk/modules/vci_mem_cache/caba/source/include/update_tab.h

@@ -11 +11 @@
 ////////////////////////////////////////////////////////////////////////
 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
@@ -25 +28 @@
   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;
@@ -38 +43 @@
 
   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;
@@ -51 +57 @@
     brdcast = i_brdcast;
     rsp     = i_rsp;
+    ack     = i_ack;
     srcid       = i_srcid;
     trdid       = i_trdid;
@@ -64 +71 @@
     brdcast = source.brdcast;
     rsp     = source.rsp;
+    ack     = source.ack;
     srcid   = source.srcid;
     trdid   = source.trdid;
@@ -80 +88 @@
     brdcast= false;
     rsp    = false;
+    ack    = false;
     srcid  = 0;
     trdid  = 0;
@@ -98 +107 @@
     brdcast= source.brdcast;
     rsp    = source.rsp;
+    ack    = source.ack  ;
     srcid  = source.srcid;
     trdid  = source.trdid;
@@ -108 +118 @@
   // 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;
   }
 };
@@ -126 +138 @@
 class UpdateTab{
 
-  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;
 
@@ -149 +161 @@
   // 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();
     }
@@ -165 +180 @@
   }
 
-
   /////////////////////////////////////////////////////////////////////
   // 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();
+  }
 
   /////////////////////////////////////////////////////////////////////
@@ -200 +212 @@
   ///////////////////////////////////////////////////////////////////////////
   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;
@@ -235 +251 @@
   /////////////////////////////////////////////////////////////////////
   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;
     }
@@ -252 +271 @@
   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;
@@ -265 +283 @@
   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;
       }
@@ -274 +399 @@
 
   /////////////////////////////////////////////////////////////////////
-  // 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;

trunk/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

@@ -77 +77 @@
 
       /* 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
       };
 
@@ -144 +146 @@
         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_INVAL,
+        CONFIG_BC_UPT_LOCK,
+        CONFIG_BC_SEND,
+        CONFIG_BC_WAIT,
+        
+        CONFIG_UPT_WAIT,
+
+        CONFIG_UPT_LOCK,
+
+        CONFIG_HEAP_REQ
       };
 
@@ -277 +300 @@
         CLEANUP_UPT_CLEAR,
         CLEANUP_WRITE_RSP,
-        CLEANUP_SEND_ACK
+        CLEANUP_CONFIG_ACK,
+        CLEANUP_SEND_CLACK
       };
 
@@ -284 +308 @@
       {
         ALLOC_DIR_RESET,
+        ALLOC_DIR_CONFIG,
         ALLOC_DIR_READ,
         ALLOC_DIR_WRITE,
@@ -304 +329 @@
       enum alloc_upt_fsm_state_e
       {
+        ALLOC_UPT_CONFIG,
         ALLOC_UPT_WRITE,
         ALLOC_UPT_XRAM_RSP,
@@ -350 +376 @@
       };
 
+      /* 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;
@@ -373 +394 @@
       // 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
@@ -391 +422 @@
       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;
 
@@ -407 +449 @@
       VciMemCache(
           sc_module_name name,                                // Instance Name
-          const soclib::common::MappingTable &mtp,            // Mapping table direct network
-          const soclib::common::MappingTable &mtx,            // Mapping table 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                       max_copies,      // max number of copies
           const size_t                       heap_size=HEAP_ENTRIES,
           const size_t                       trt_lines=TRT_ENTRIES, 
@@ -437 +479 @@
 
       // 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
@@ -458 +501 @@
       size_t                             m_max_copies;       // max number of copies in heap
       GenericLLSCGlobalTable
-      < 32  ,                              // number of slots
-        4096,                              // number of processors in the system
-        8000,                              // registration life (# of LL operations)
-        addr_t >  m_llsc_table;            // ll/sc global registration table
+      < 32  ,    // number of slots
+        4096,    // number of processors in the system
+        8000,    // registration life (# of LL operations)
+        addr_t >                         m_llsc_table;       // ll/sc registration table
 
       // adress masks
@@ -511 +554 @@
       // (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_way;        // selected way
+      sc_signal<size_t>   r_config_count;      // number of copies
+      sc_signal<size_t>   r_config_upt_index;  // UPT index
+      sc_signal<bool>     r_config_is_cnt;     // counter mode (broadcast required)
+
+      // 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<size_t>   r_config_to_cc_send_nline;        // line index
+      sc_signal<size_t>   r_config_to_cc_send_trdid;        // UPT index
+
       ///////////////////////////////////////////////////////
       // Registers controlled by the READ fsm
       ///////////////////////////////////////////////////////
 
-      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
+      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)
@@ -626 +705 @@
       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<bool>     r_multi_ack_to_tgt_rsp_req;   // valid request
@@ -662 +744 @@
       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