Ignore:
Timestamp:
Jul 24, 2013, 8:47:40 AM (9 years ago)
Author:
cfuguet
Message:


Merging vci_mem_cache from branches/v5 to trunk [441-467]

=-----------------------------------------------------------------------
r441 | cfuguet | 2013-07-17 10:54:07 +0200 (Wed, 17 Jul 2013) | 14 lines

Modifications in branches/v5/vci_mem_cache:

  • Changing name of CC DSPIN ports: + p_dspin_in => p_dspin_p2m + p_dspin_out => p_dspin_m2p
  • Splitting the Update Table in two tables: + UPT (Update Table): Stores the MULTI-UPDATE transactions + IVT (Invalidate Table): Stores the MULTI/BROADCAST INVALIDATE

transactions

Each table has its own allocator FSM: r_alloc_upt and r_alloc_ivt

=-----------------------------------------------------------------------
r442 | cfuguet | 2013-07-17 12:13:51 +0200 (Wed, 17 Jul 2013) | 13 lines

Modifications in branches/v5/modules/vci_mem_cache:

  • Introducing third port for the CLACK network.
  • CLEANUP FSM is no more a CC_SEND FSM client.
  • CLEANUP FSM controls directly the p_dspin_clack port

=-----------------------------------------------------------------------
r445 | cfuguet | 2013-07-18 10:49:36 +0200 (Thu, 18 Jul 2013) | 7 lines

Bugfix in vci_mem_cache:

  • Adding missing "strings" for print_trace() function
  • Adding alloc_ivt fsm (Invalidate Table) in the

print_trace() function

=-----------------------------------------------------------------------
r455 | cfuguet | 2013-07-19 10:16:17 +0200 (Fri, 19 Jul 2013) | 8 lines

Merged

/trunk/modules/vci_mem_cache:449 with
/branches/v5/modules/vci_mem_cache:446.

This merge introduces into the branch the last modifications concerning
the VCI memory cache configuration interface


Merging vci_cc_vcache_wrapper from branches/v5 to trunk [444-467]

=-----------------------------------------------------------------------
r444 | cfuguet | 2013-07-17 14:46:46 +0200 (Wed, 17 Jul 2013) | 7 lines

Modifications in branches/v5/modules/vci_cc_vcache_wrapper:

  • Renaming FROM_MC DSPIN flits fields in M2P
  • Renaming FROM_L1 DSPIN flits fields in P2M
  • Renaming CLEANUP_ACK DSPIN flits fields in CLACK

=-----------------------------------------------------------------------
r446 | cfuguet | 2013-07-18 11:37:47 +0200 (Thu, 18 Jul 2013) | 13 lines

Modifications in vci_cc_vcache_wrapper:

  • Merging the states DCACHE/ICACHE_CC_BROADCAST and DCACHE/ICACHE_CC_INVAL. This is because, the BROADCAST INVALIDATE and the MULTICAST INVALIDATE are both acknowledged by a CLEANUP.
  • Adding third port for the clack coherence network.
  • Renaming the port dspin_in to dspin_m2p and the port dspin_out to dspin_p2m

=-----------------------------------------------------------------------
r454 | haoliu | 2013-07-19 10:15:13 +0200 (Fri, 19 Jul 2013) | 2 lines

modified CC_RECEIVE FSM and CC_CHECK FSM (icache and dcache) for new
version V5

=-----------------------------------------------------------------------
r461 | cfuguet | 2013-07-19 15:49:43 +0200 (Fri, 19 Jul 2013) | 9 lines

Bugfix in vci_cc_vcache_wrapper:

  • In the states DCACHE/ICACHE CC_UPDT the FSM returns to the state CC_CHECK only when the cc_send_req is occupied.

We must not return to the CC_CHECK state if not ROK of the
DATA FIFO because the counter word counter will be reset.

=-----------------------------------------------------------------------
r462 | cfuguet | 2013-07-19 16:26:26 +0200 (Fri, 19 Jul 2013) | 8 lines

Modification in vci_cc_vcache_wrapper:

  • Optimization in DCACHE/ICACHE CC_CHECK state. We can handle a CLACK and a CC request if the latter does a MISS match. This is because the CC request doing MISS match does not need to access the directory

=-----------------------------------------------------------------------
r463 | cfuguet | 2013-07-19 16:52:06 +0200 (Fri, 19 Jul 2013) | 12 lines

Modification in vci_cc_vcache_wrapper:

  • Optimization in DCACHE/ICACHE CC_CHECK state. If pending request to CC_SEND, we wait in the CC_CHECK state. Doing this, during the wait, we can handle incoming CLACK avoiding any deadlock situation.

The states CC_UPDT and CC_INVAL do not need to test anymore if
there is a pending request to CC_SEND.


Merging tsar_generic_xbar from branches/v5 to trunk [447-467]

=-----------------------------------------------------------------------
r447 | cfuguet | 2013-07-18 16:12:05 +0200 (Thu, 18 Jul 2013) | 8 lines

Adding tsar_generic_xbar platform in branches/v5/platforms:

  • This platform contains a third local crossbar interconnect for the CLACK network.
  • It works only in a monocluster topology

=-----------------------------------------------------------------------
r448 | cfuguet | 2013-07-18 17:51:18 +0200 (Thu, 18 Jul 2013) | 9 lines

Modification in branches/v5/platforms/tsar_generic_xbar:

  • Adding a DSPIN router to the platform to allow the inter-cluster communication for the CLACK commands.

With this modification, the tsar_generic_xbar platform can be used
for multi-cluster simulations

=-----------------------------------------------------------------------
r466 | cfuguet | 2013-07-23 17:01:49 +0200 (Tue, 23 Jul 2013) | 9 lines

Modifications in branches/v5 vci_mem_cache:

  • Replacing the third router CLACK by a third virtual channel in the new virtual_dspin_router supporting several virtual channels.

The third channel has been added in the COMMAND router.

=-----------------------------------------------------------------------
r467 | cfuguet | 2013-07-23 17:23:13 +0200 (Tue, 23 Jul 2013) | 5 lines

Modifications in branches/v5 tsar_generic_xbar:

  • Adding preprocessor conditional statements for ALMOS support


Merging dspin_dhccp_param from branches/v5 to trunk [377-467]

=-----------------------------------------------------------------------
r442 | cfuguet | 2013-07-17 12:13:51 +0200 (Wed, 17 Jul 2013) | 13 lines

Modifications in branches/v5/communication/dspin_dhccp_param:

  • Renaming FROM_MC fields in M2P
  • Renaming FROM_L1 fields in P2M
  • Renaming CLEANUP_ACK fields in CLACK
Location:
trunk/modules/vci_mem_cache
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/modules/vci_mem_cache

  • trunk/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r449 r468  
    9999  "CC_SEND_WRITE_IDLE",
    100100  "CC_SEND_CAS_IDLE",
    101   "CC_SEND_CLEANUP_IDLE",
    102101  "CC_SEND_CONFIG_INVAL_HEADER",
    103102  "CC_SEND_CONFIG_INVAL_NLINE",
    104103  "CC_SEND_CONFIG_BRDCAST_HEADER",
    105104  "CC_SEND_CONFIG_BRDCAST_NLINE",
    106   "CC_SEND_CLEANUP_ACK",
    107105  "CC_SEND_XRAM_RSP_BRDCAST_HEADER",
    108106  "CC_SEND_XRAM_RSP_BRDCAST_NLINE",
     
    136134  "CONFIG_DIR_REQ",
    137135  "CONFIG_DIR_ACCESS",
    138   "CONFIG_DIR_UPT_LOCK",
     136  "CONFIG_DIR_IVT_LOCK",
    139137  "CONFIG_BC_SEND",
    140138  "CONFIG_BC_WAIT",
     
    180178  "WRITE_MISS_XRAM_REQ",
    181179  "WRITE_BC_TRT_LOCK",
    182   "WRITE_BC_UPT_LOCK",
     180  "WRITE_BC_IVT_LOCK",
    183181  "WRITE_BC_DIR_INVAL",
    184182  "WRITE_BC_CC_SEND",
     
    235233  "CAS_UPT_NEXT",
    236234  "CAS_BC_TRT_LOCK",
    237   "CAS_BC_UPT_LOCK",
     235  "CAS_BC_IVT_LOCK",
    238236  "CAS_BC_DIR_INVAL",
    239237  "CAS_BC_CC_SEND",
     
    258256  "CLEANUP_HEAP_CLEAN",
    259257  "CLEANUP_HEAP_FREE",
    260   "CLEANUP_UPT_LOCK",
    261   "CLEANUP_UPT_DECREMENT",
    262   "CLEANUP_UPT_CLEAR",
     258  "CLEANUP_IVT_LOCK",
     259  "CLEANUP_IVT_DECREMENT",
     260  "CLEANUP_IVT_CLEAR",
    263261  "CLEANUP_WRITE_RSP",
    264262  "CLEANUP_CONFIG_ACK",
     
    268266{
    269267  "ALLOC_DIR_RESET",
     268  "ALLOC_DIR_CONFIG",
    270269  "ALLOC_DIR_READ",
    271270  "ALLOC_DIR_WRITE",
     
    285284{
    286285  "ALLOC_UPT_WRITE",
    287   "ALLOC_UPT_XRAM_RSP",
    288   "ALLOC_UPT_MULTI_ACK",
    289   "ALLOC_UPT_CLEANUP",
    290   "ALLOC_UPT_CAS"
     286  "ALLOC_UPT_CAS",
     287  "ALLOC_UPT_MULTI_ACK"
     288};
     289const char *alloc_ivt_fsm_str[] =
     290{
     291  "ALLOC_IVT_WRITE",
     292  "ALLOC_IVT_XRAM_RSP",
     293  "ALLOC_IVT_CLEANUP",
     294  "ALLOC_IVT_CAS",
     295  "ALLOC_IVT_CONFIG"
    291296};
    292297const char *alloc_heap_fsm_str[] =
     
    328333  const size_t        trt_lines,         // number of TRT entries
    329334  const size_t        upt_lines,         // number of UPT entries
     335  const size_t        ivt_lines,         // number of IVT entries
    330336  const size_t        debug_start_cycle,
    331337  const bool          debug_ok)
     
    337343    p_vci_tgt( "p_vci_tgt" ),
    338344    p_vci_ixr( "p_vci_ixr" ),
    339     p_dspin_in( "p_dspin_in" ),
    340     p_dspin_out( "p_dspin_out" ),
     345    p_dspin_p2m( "p_dspin_p2m" ),
     346    p_dspin_m2p( "p_dspin_m2p" ),
     347    p_dspin_clack( "p_dspin_clack" ),
    341348
    342349    m_seglist( mtp.getSegmentList(tgtid_d) ),
     
    355362    m_upt_lines(upt_lines),
    356363    m_upt(upt_lines),
     364    m_ivt(ivt_lines),
    357365    m_cache_directory(nways, nsets, nwords, vci_param_int::N),
    358366    m_cache_data(nways, nsets, nwords),
     
    446454    r_alloc_trt_fsm("r_alloc_trt_fsm"),
    447455    r_alloc_upt_fsm("r_alloc_upt_fsm"),
     456    r_alloc_ivt_fsm("r_alloc_ivt_fsm"),
    448457    r_alloc_heap_fsm("r_alloc_heap_fsm"),
    449458    r_alloc_heap_reset_cpt("r_alloc_heap_reset_cpt")
     
    623632            << " | " << ixr_cmd_fsm_str[r_ixr_cmd_fsm.read()]
    624633            << " | " << ixr_rsp_fsm_str[r_ixr_rsp_fsm.read()]
    625             << " | " << xram_rsp_fsm_str[r_xram_rsp_fsm] << std::endl;
     634            << " | " << xram_rsp_fsm_str[r_xram_rsp_fsm.read()] << std::endl;
    626635  std::cout << "  "  << alloc_dir_fsm_str[r_alloc_dir_fsm.read()]
    627636            << " | " << alloc_trt_fsm_str[r_alloc_trt_fsm.read()]
    628637            << " | " << alloc_upt_fsm_str[r_alloc_upt_fsm.read()]
     638            << " | " << alloc_ivt_fsm_str[r_alloc_ivt_fsm.read()]
    629639            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
    630640}
     
    702712    r_alloc_trt_fsm  = ALLOC_TRT_READ;
    703713    r_alloc_upt_fsm  = ALLOC_UPT_WRITE;
     714    r_alloc_ivt_fsm  = ALLOC_IVT_XRAM_RSP;
    704715    r_ixr_rsp_fsm    = IXR_RSP_IDLE;
    705716    r_xram_rsp_fsm   = XRAM_RSP_IDLE;
     
    714725    m_trt.init();
    715726    m_upt.init();
     727    m_ivt.init();
    716728    m_llsc_table.init();
    717729
     
    15341546              r_config_dir_next_ptr   = entry.ptr;
    15351547
    1536               r_config_fsm    = CONFIG_DIR_UPT_LOCK;
     1548              r_config_fsm    = CONFIG_DIR_IVT_LOCK;
    15371549          }
    15381550          else if ( entry.valid and                       // hit & sync command
     
    15631575      }
    15641576      /////////////////////////
    1565       case CONFIG_DIR_UPT_LOCK:  // enter this state in case of INVAL command
    1566                                  // Try to get both DIR & UPT locks, and return
    1567                                  // to LOOP state if UPT full.
    1568                                  // Register inval in UPT, and invalidate the
    1569                                  // directory if UPT not full.
    1570       {
    1571           if ( r_alloc_upt_fsm.read() == ALLOC_UPT_CONFIG )
     1577      case CONFIG_DIR_IVT_LOCK:  // enter this state in case of INVAL command
     1578                                 // Try to get both DIR & IVT locks, and return
     1579                                 // to LOOP state if IVT full.
     1580                                 // Register inval in IVT, and invalidate the
     1581                                 // directory if IVT not full.
     1582      {
     1583          if ( r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG )
    15721584          {
    15731585              size_t set        = m_y[(addr_t)(r_config_address.read())];
     
    15831595#if DEBUG_MEMC_CONFIG
    15841596if(m_debug)
    1585 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
     1597std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
    15861598          << " No copies in L1 : inval DIR entry"  << std::endl;
    15871599#endif
    15881600              }
    1589               else    // try to register inval in UPT
     1601              else    // try to register inval in IVT
    15901602              {
    15911603                  bool        wok       = false;
     
    15981610                  size_t      nb_copies = r_config_dir_count.read();
    15991611
    1600                   wok = m_upt.set(false,       // it's an inval transaction
     1612                  wok = m_ivt.set(false,       // it's an inval transaction
    16011613                                  broadcast,   
    16021614                                  false,       // no response required
     
    16091621                                  index);
    16101622
    1611                   if ( wok )  // UPT success => inval DIR slot
     1623                  if ( wok )  // IVT success => inval DIR slot
    16121624                  {
    16131625                      m_cache_directory.inval( way, set );
    1614                       r_config_upt_index = index;
     1626                      r_config_ivt_index = index;
    16151627                      if ( broadcast )  r_config_fsm = CONFIG_BC_SEND;
    16161628                      else              r_config_fsm = CONFIG_INV_SEND;
     
    16181630#if DEBUG_MEMC_CONFIG
    16191631if(m_debug)
    1620 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1621           << " Inval DIR entry and register inval in UPT"
     1632std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1633          << " Inval DIR entry and register inval in IVT"
    16221634          << " : index = " << std::dec << index
    16231635          << " / broadcast = " << broadcast << std::endl;
    16241636#endif
    16251637                  }
    1626                   else       // UPT full => release both DIR and UPT locks
     1638                  else       // IVT full => release both DIR and IVT locks
    16271639                  {
    16281640                      r_config_fsm = CONFIG_LOOP;
     
    16301642#if DEBUG_MEMC_CONFIG
    16311643if(m_debug)
    1632 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1633           << " UPT full : release DIR & UPT locks and retry" << std::endl;
     1644std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1645          << " IVT full : release DIR & IVT locks and retry" << std::endl;
    16341646#endif
    16351647                  }
     
    16461658              r_config_to_cc_send_multi_req   = false;
    16471659              r_config_to_cc_send_brdcast_req = true;
    1648               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1660              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    16491661              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    16501662              r_cleanup_to_config_ack         = false;
     
    16861698              r_config_to_cc_send_multi_req   = true;
    16871699              r_config_to_cc_send_brdcast_req = false;
    1688               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1700              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    16891701              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    16901702              r_multi_ack_to_config_ack       = false;
     
    18481860  switch(r_read_fsm.read())
    18491861  {
    1850       ///////////////
    1851       case READ_IDLE:  // waiting a read request
    1852       {
     1862    ///////////////
     1863    case READ_IDLE:  // waiting a read request
     1864    {
    18531865      if(m_cmd_read_addr_fifo.rok())
    18541866      {
    18551867
    18561868#if DEBUG_MEMC_READ
    1857 if(m_debug)
    1858 std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
    1859           << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
    1860           << " / srcid = " << m_cmd_read_srcid_fifo.read()
    1861           << " / trdid = " << m_cmd_read_trdid_fifo.read()
    1862           << " / pktid = " << m_cmd_read_pktid_fifo.read()
    1863           << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
     1869        if(m_debug)
     1870          std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
     1871            << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
     1872            << " / srcid = " << m_cmd_read_srcid_fifo.read()
     1873            << " / trdid = " << m_cmd_read_trdid_fifo.read()
     1874            << " / pktid = " << m_cmd_read_pktid_fifo.read()
     1875            << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
    18641876#endif
    18651877        r_read_fsm = READ_DIR_REQ;
     
    19611973
    19621974    {
    1963         if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    1964         {
    1965             // check if this is an instruction read, this means pktid is either
    1966             // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
    1967             // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    1968             bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    1969             // check if this is a cached read, this means pktid is either
    1970             // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
    1971             // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    1972             bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
    1973             bool is_cnt       = r_read_is_cnt.read();
    1974 
    1975             // read data in the cache
    1976             size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    1977             size_t way        = r_read_way.read();
    1978 
    1979             m_cache_data.read_line(way, set, r_read_data);
    1980 
    1981             if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
    1982 
    1983             // update the cache directory
    1984             DirectoryEntry entry;
    1985             entry.valid   = true;
    1986             entry.is_cnt  = is_cnt;
    1987             entry.dirty   = r_read_dirty.read();
    1988             entry.tag     = r_read_tag.read();
    1989             entry.lock    = r_read_lock.read();
    1990             entry.ptr     = r_read_ptr.read();
    1991 
    1992             if(cached_read)   // Cached read => we must update the copies
    1993             {
    1994                 if(!is_cnt)  // Not counter mode
    1995                 {
    1996                     entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     1975      if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     1976      {
     1977        // check if this is an instruction read, this means pktid is either
     1978        // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
     1979        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     1980        bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
     1981        // check if this is a cached read, this means pktid is either
     1982        // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
     1983        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     1984        bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
     1985        bool is_cnt       = r_read_is_cnt.read();
     1986
     1987        // read data in the cache
     1988        size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
     1989        size_t way        = r_read_way.read();
     1990
     1991        m_cache_data.read_line(way, set, r_read_data);
     1992
     1993        if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
     1994
     1995        // update the cache directory
     1996        DirectoryEntry entry;
     1997        entry.valid   = true;
     1998        entry.is_cnt  = is_cnt;
     1999        entry.dirty   = r_read_dirty.read();
     2000        entry.tag     = r_read_tag.read();
     2001        entry.lock    = r_read_lock.read();
     2002        entry.ptr     = r_read_ptr.read();
     2003
     2004        if(cached_read)   // Cached read => we must update the copies
     2005        {
     2006          if(!is_cnt)  // Not counter mode
     2007          {
     2008            entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
    19972009#if L1_MULTI_CACHE
    1998                     entry.owner.cache_id = m_cmd_read_pktid_fifo.read();
    1999 #endif
    2000                     entry.owner.inst     = inst_read;
    2001                     entry.count          = r_read_count.read() + 1;
    2002                 }
    2003                 else  // Counter mode
    2004                 {
    2005                     entry.owner.srcid    = 0;
     2010            entry.owner.cache_id = m_cmd_read_pktid_fifo.read();
     2011#endif
     2012            entry.owner.inst     = inst_read;
     2013            entry.count          = r_read_count.read() + 1;
     2014          }
     2015          else  // Counter mode
     2016          {
     2017            entry.owner.srcid    = 0;
    20062018#if L1_MULTI_CACHE
    2007                     entry.owner.cache_id = 0;
    2008 #endif
    2009                     entry.owner.inst     = false;
    2010                     entry.count          = r_read_count.read() + 1;
    2011                 }
    2012             }
    2013             else            // Uncached read
    2014             {
    2015                 entry.owner.srcid     = r_read_copy.read();
     2019            entry.owner.cache_id = 0;
     2020#endif
     2021            entry.owner.inst     = false;
     2022            entry.count          = r_read_count.read() + 1;
     2023          }
     2024        }
     2025        else            // Uncached read
     2026        {
     2027          entry.owner.srcid     = r_read_copy.read();
    20162028#if L1_MULTI_CACHE
    2017                 entry.owner.cache_id  = r_read_copy_cache.read();
    2018 #endif
    2019                 entry.owner.inst      = r_read_copy_inst.read();
    2020                 entry.count           = r_read_count.read();
    2021             }
     2029          entry.owner.cache_id  = r_read_copy_cache.read();
     2030#endif
     2031          entry.owner.inst      = r_read_copy_inst.read();
     2032          entry.count           = r_read_count.read();
     2033        }
    20222034
    20232035#if DEBUG_MEMC_READ
    2024 if(m_debug)
    2025 std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    2026           << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
    2027           << " / set = " << std::dec << set
    2028           << " / way = " << way
    2029           << " / owner_id = " << std::hex << entry.owner.srcid
    2030           << " / owner_ins = " << std::dec << entry.owner.inst
    2031           << " / count = " << entry.count
    2032           << " / is_cnt = " << entry.is_cnt << std::endl;
    2033 #endif
    2034 
    2035             m_cache_directory.write(set, way, entry);
    2036             r_read_fsm    = READ_RSP;
    2037         }
    2038         break;
     2036        if(m_debug)
     2037          std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
     2038            << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
     2039            << " / set = " << std::dec << set
     2040            << " / way = " << way
     2041            << " / owner_id = " << std::hex << entry.owner.srcid
     2042            << " / owner_ins = " << std::dec << entry.owner.inst
     2043            << " / count = " << entry.count
     2044            << " / is_cnt = " << entry.is_cnt << std::endl;
     2045#endif
     2046
     2047        m_cache_directory.write(set, way, entry);
     2048        r_read_fsm    = READ_RSP;
     2049      }
     2050      break;
    20392051    }
    20402052    ///////////////////
     
    27502762
    27512763        wok = m_upt.set(true,  // it's an update transaction
    2752                         false,    // it's not a broadcast
    2753                         true,     // response required
    2754                         false,    // no acknowledge required
     2764                        false, // it's not a broadcast
     2765                        true,  // response required
     2766                        false, // no acknowledge required
    27552767                        srcid,   
    27562768                        trdid,
     
    29042916          entry.owner.inst)             // put the next srcid in the fifo
    29052917      {
    2906         dec_upt_counter                 = false;
     2918        dec_upt_counter                = false;
    29072919        write_to_cc_send_fifo_put      = true;
    29082920        write_to_cc_send_fifo_inst     = entry.owner.inst;
     
    29572969      {
    29582970        r_write_to_cc_send_multi_req = true;
    2959         if(r_write_to_dec.read() or dec_upt_counter)   r_write_fsm = WRITE_UPT_DEC;
     2971        if(r_write_to_dec.read() or dec_upt_counter)  r_write_fsm = WRITE_UPT_DEC;
    29602972        else                                          r_write_fsm = WRITE_IDLE;
    29612973      }
     
    32003212        {
    32013213          r_write_trt_index = wok_index;
    3202           r_write_fsm       = WRITE_BC_UPT_LOCK;
     3214          r_write_fsm       = WRITE_BC_IVT_LOCK;
    32033215        }
    32043216        else  // wait an empty entry in TRT
     
    32173229
    32183230    //////////////////////
    3219     case WRITE_BC_UPT_LOCK:      // register BC transaction in UPT
    3220     {
    3221       if(r_alloc_upt_fsm.read() == ALLOC_UPT_WRITE)
     3231    case WRITE_BC_IVT_LOCK:      // register BC transaction in IVT
     3232    {
     3233      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    32223234      {
    32233235        bool        wok       = false;
     
    32293241        size_t      nb_copies = r_write_count.read();
    32303242
    3231         wok = m_upt.set(false,  // it's an inval transaction
    3232                         true,     // it's a broadcast
    3233                         true,     // response required
    3234                         false,    // no acknowledge required
     3243        wok = m_ivt.set(false,  // it's an inval transaction
     3244                        true,   // it's a broadcast
     3245                        true,   // response required
     3246                        false,  // no acknowledge required
    32353247                        srcid,
    32363248                        trdid,
     
    32423254#if DEBUG_MEMC_WRITE
    32433255if( m_debug and wok )
    3244 std::cout << "  <MEMC " << name() << " WRITE_BC_UPT_LOCK> Register broadcast inval in UPT"
     3256std::cout << "  <MEMC " << name() << " WRITE_BC_IVT_LOCK> Register broadcast inval in IVT"
    32453257          << " / nb_copies = " << r_write_count.read() << std::endl;
    32463258#endif
     
    32483260
    32493261        if(wok) r_write_fsm = WRITE_BC_DIR_INVAL;
    3250         else       r_write_fsm = WRITE_WAIT;
     3262        else    r_write_fsm = WRITE_WAIT;
    32513263      }
    32523264      break;
     
    32593271      // and invalidate the line in directory
    32603272      if((r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE) or
    3261           (r_alloc_upt_fsm.read() != ALLOC_UPT_WRITE) or
    3262           (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
     3273         (r_alloc_ivt_fsm.read() != ALLOC_IVT_WRITE) or
     3274         (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
    32633275      {
    32643276        std::cout << "VCI_MEM_CACHE ERROR " << name() << " WRITE_BC_DIR_INVAL state" << std::endl;
    3265         std::cout << "bad TRT, DIR, or UPT allocation" << std::endl;
     3277        std::cout << "bad TRT, DIR, or IVT allocation" << std::endl;
    32663278        exit(0);
    32673279      }
     
    37913803    }
    37923804    /////////////////////////
    3793     case XRAM_RSP_INVAL_LOCK: // Take the UPT lock to check a possible pending inval
    3794     {
    3795       if(r_alloc_upt_fsm == ALLOC_UPT_XRAM_RSP)
     3805    case XRAM_RSP_INVAL_LOCK: // Take the IVT lock to check a possible pending inval
     3806    {
     3807      if(r_alloc_ivt_fsm == ALLOC_IVT_XRAM_RSP)
    37963808      {
    37973809        size_t index = 0;
    3798         if(m_upt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
     3810        if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
    37993811        {
    38003812          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    38033815if(m_debug)
    38043816std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3805           << " Get acces to UPT, but line invalidation registered"
     3817          << " Get acces to IVT, but line invalidation registered"
    38063818          << " / nline = " << std::hex << r_xram_rsp_trt_buf.nline
    38073819          << " / index = " << std::dec << index << std::endl;
     
    38093821
    38103822        }
    3811         else if(m_upt.is_full() and r_xram_rsp_victim_inval.read()) // UPT full
     3823        else if(m_ivt.is_full() and r_xram_rsp_victim_inval.read()) // IVT full
    38123824        {
    38133825          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    38163828if(m_debug)
    38173829std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3818           << " Get acces to UPT, but inval required and UPT full" << std::endl;
     3830          << " Get acces to IVT, but inval required and IVT full" << std::endl;
    38193831#endif
    38203832        }
     
    38263838if(m_debug)
    38273839std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3828           << " Get acces to UPT" << std::endl;
     3840          << " Get acces to IVT" << std::endl;
    38293841#endif
    38303842        }
     
    38463858    ///////////////////////
    38473859    case XRAM_RSP_DIR_UPDT:   // updates the cache (both data & directory)
    3848                               // and possibly set an inval request in UPT
     3860                              // and possibly set an inval request in IVT
    38493861    {
    38503862      // check if this is an instruction read, this means pktid is either
     
    39043916      m_cache_directory.write(set, way, entry);
    39053917
    3906       // request an invalidattion request in UPT for victim line
     3918      // request an invalidattion request in IVT for victim line
    39073919      if(r_xram_rsp_victim_inval.read())
    39083920      {
     
    39113923        size_t count_copies = r_xram_rsp_victim_count.read();
    39123924
    3913         bool   wok = m_upt.set(false,      // it's an inval transaction
     3925        bool   wok = m_ivt.set(false,      // it's an inval transaction
    39143926                               broadcast,  // set broadcast bit
    39153927                               false,      // no response required
     
    39223934                               index);
    39233935
    3924         r_xram_rsp_upt_index = index;
     3936        r_xram_rsp_ivt_index = index;
    39253937
    39263938        if(!wok)
    39273939        {
    39283940          std::cout << "VCI_MEM_CACHE ERROR " << name() << " XRAM_RSP_DIR_UPDT"
    3929                     << " update_tab entry free but write unsuccessful" << std::endl;
     3941                    << " invalidate_tab entry free but write unsuccessful" << std::endl;
    39303942          exit(0);
    39313943        }
     
    40364048        r_xram_rsp_to_cc_send_brdcast_req  = r_xram_rsp_victim_is_cnt.read();
    40374049        r_xram_rsp_to_cc_send_nline        = r_xram_rsp_victim_nline.read();
    4038         r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_upt_index;
     4050        r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_ivt_index;
    40394051        xram_rsp_to_cc_send_fifo_srcid     = r_xram_rsp_victim_copy.read();
    40404052        xram_rsp_to_cc_send_fifo_inst      = r_xram_rsp_victim_copy_inst.read();
     
    42524264        DspinDhccpParam::dspin_get(
    42534265            flit,
    4254             DspinDhccpParam::FROM_L1_TYPE);
     4266            DspinDhccpParam::P2M_TYPE);
    42554267
    42564268      r_cleanup_way_index =
     
    43814393      else                // miss : check UPT for a pending invalidation transaction
    43824394      {
    4383         r_cleanup_fsm = CLEANUP_UPT_LOCK;
     4395        r_cleanup_fsm = CLEANUP_IVT_LOCK;
    43844396      }
    43854397
     
    48394851    }
    48404852    //////////////////////
    4841     case CLEANUP_UPT_LOCK:   // get the lock protecting the UPT to search a pending
     4853    case CLEANUP_IVT_LOCK:   // get the lock protecting the IVT to search a pending
    48424854                             // invalidate transaction matching the cleanup
    48434855    {
    4844       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP) break;
     4856      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    48454857
    48464858      size_t index = 0;
    48474859      bool   match_inval;
    48484860
    4849       match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
     4861      match_inval = m_ivt.search_inval(r_cleanup_nline.read(), index);
    48504862
    48514863      if ( not match_inval )     // no pending inval
     
    48564868if(m_debug)
    48574869std::cout << "  <MEMC " << name()
    4858           << " CLEANUP_UPT_LOCK> Unexpected cleanup"
    4859           << " with no corresponding UPT entry:"
     4870          << " CLEANUP_IVT_LOCK> Unexpected cleanup"
     4871          << " with no corresponding IVT entry:"
    48604872          << " address = " << std::hex
    48614873          << (r_cleanup_nline.read() *4*m_words)
     
    48664878
    48674879      // pending inval
    4868       r_cleanup_write_srcid = m_upt.srcid(index);
    4869       r_cleanup_write_trdid = m_upt.trdid(index);
    4870       r_cleanup_write_pktid = m_upt.pktid(index);
    4871       r_cleanup_need_rsp    = m_upt.need_rsp(index);
    4872       r_cleanup_need_ack    = m_upt.need_ack(index);
     4880      r_cleanup_write_srcid = m_ivt.srcid(index);
     4881      r_cleanup_write_trdid = m_ivt.trdid(index);
     4882      r_cleanup_write_pktid = m_ivt.pktid(index);
     4883      r_cleanup_need_rsp    = m_ivt.need_rsp(index);
     4884      r_cleanup_need_ack    = m_ivt.need_ack(index);
    48734885      r_cleanup_index       = index;
    48744886
    4875       r_cleanup_fsm         = CLEANUP_UPT_DECREMENT;
     4887      r_cleanup_fsm         = CLEANUP_IVT_DECREMENT;
    48764888
    48774889#if DEBUG_MEMC_CLEANUP
    48784890if(m_debug)
    48794891std::cout << "  <MEMC " << name()
    4880           << " CLEANUP_UPT_LOCK> Cleanup matching pending"
    4881           << " invalidate transaction on UPT:"
     4892          << " CLEANUP_IVT_LOCK> Cleanup matching pending"
     4893          << " invalidate transaction on IVT:"
    48824894          << " address = " << std::hex << r_cleanup_nline.read() * m_words * 4
    4883           << " / upt_entry = " << index << std::endl;
     4895          << " / ivt_entry = " << index << std::endl;
    48844896#endif
    48854897      break;
    48864898    }
    48874899    ///////////////////////////
    4888     case CLEANUP_UPT_DECREMENT:   // decrement response counter in UPT matching entry
    4889     {
    4890       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     4900    case CLEANUP_IVT_DECREMENT: // decrement response counter in IVT matching entry
     4901    {
     4902      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    48914903      {
    48924904        std::cout
    48934905            << "VCI_MEM_CACHE ERROR "         << name()
    4894             << " CLEANUP_UPT_DECREMENT state" << std::endl
    4895             << "Bad UPT allocation"
     4906            << " CLEANUP_IVT_DECREMENT state" << std::endl
     4907            << "Bad IVT allocation"
    48964908            << std::endl;
    48974909
     
    49004912
    49014913      size_t count = 0;
    4902       m_upt.decrement(r_cleanup_index.read(), count);
     4914      m_ivt.decrement(r_cleanup_index.read(), count);
    49034915
    49044916      if(count == 0)   // multi inval transaction completed
    49054917      {
    4906         r_cleanup_fsm = CLEANUP_UPT_CLEAR;
     4918        r_cleanup_fsm = CLEANUP_IVT_CLEAR;
    49074919      }
    49084920      else             // multi inval transaction not completed
     
    49134925#if DEBUG_MEMC_CLEANUP
    49144926if(m_debug)
    4915 std::cout << "  <MEMC " << name() << " CLEANUP_UPT_DECREMENT>"
    4916           << " Decrement response counter in UPT:"
    4917             << " UPT_index = " << r_cleanup_index.read()
     4927std::cout << "  <MEMC " << name() << " CLEANUP_IVT_DECREMENT>"
     4928          << " Decrement response counter in IVT:"
     4929            << " IVT_index = " << r_cleanup_index.read()
    49184930            << " / rsp_count = " << count << std::endl;
    49194931#endif
     
    49214933    }
    49224934    ///////////////////////
    4923     case CLEANUP_UPT_CLEAR:    // Clear UPT entry
    4924     {
    4925       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     4935    case CLEANUP_IVT_CLEAR:    // Clear IVT entry
     4936    {
     4937      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    49264938      {
    49274939        std::cout
    49284940            << "VCI_MEM_CACHE ERROR "     << name()
    4929             << " CLEANUP_UPT_CLEAR state" << std::endl
    4930             << "Bad UPT allocation"
     4941            << " CLEANUP_IVT_CLEAR state" << std::endl
     4942            << "Bad IVT allocation"
    49314943            << std::endl;
    49324944
     
    49344946      }
    49354947
    4936       m_upt.clear(r_cleanup_index.read());
     4948      m_ivt.clear(r_cleanup_index.read());
    49374949
    49384950      if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
     
    49434955if(m_debug)
    49444956std::cout << "  <MEMC "      << name()
    4945           << " CLEANUP_UPT_CLEAR> Clear entry in UPT:"
    4946           << " UPT_index = " << r_cleanup_index.read() << std::endl;
     4957          << " CLEANUP_IVT_CLEAR> Clear entry in IVT:"
     4958          << " IVT_index = " << r_cleanup_index.read() << std::endl;
    49474959#endif
    49484960      break;
     
    49895001    }
    49905002    ////////////////////////
    4991     case CLEANUP_SEND_CLACK:    // acknowledgement to a cleanup command
    4992                               // on the coherence network (request to the CC_SEND FSM).
    4993                               // wait if pending request to the CC_SEND FSM
    4994     {
    4995       if(r_cleanup_to_cc_send_req.read()) break;
    4996 
    4997       r_cleanup_to_cc_send_req       = true;
    4998       r_cleanup_to_cc_send_set_index = r_cleanup_nline.read() & 0xFFFF;
    4999       r_cleanup_to_cc_send_way_index = r_cleanup_way_index.read();
    5000       r_cleanup_to_cc_send_srcid     = r_cleanup_srcid.read();
    5001       r_cleanup_to_cc_send_inst      = r_cleanup_inst.read();
     5003    case CLEANUP_SEND_CLACK:  // acknowledgement to a cleanup command
     5004                              // on the coherence CLACK network.
     5005    {
     5006      if(not p_dspin_clack.read) break;
    50025007
    50035008      r_cleanup_fsm = CLEANUP_IDLE;
     
    50075012std::cout << "  <MEMC " << name()
    50085013          << " CLEANUP_SEND_CLACK> Send the response to a cleanup request:"
    5009           << " srcid = " << std::dec << r_cleanup_srcid.read() << std::endl;
     5014          << " nline = "   << std::hex << r_cleanup_nline.read()
     5015          << " / way = "   << std::dec << r_cleanup_way.read()
     5016          << " / srcid = " << std::dec << r_cleanup_srcid.read()
     5017          << std::endl;
    50105018#endif
    50115019      break;
     
    52425250                !r_cas_to_cc_send_brdcast_req.read())
    52435251        {
    5244           r_cas_fsm = CAS_UPT_LOCK;     // multi update required
     5252          r_cas_fsm = CAS_UPT_LOCK;       // multi update required
    52455253        }
    52465254        else
     
    55075515          {
    55085516            r_cas_trt_index = wok_index;
    5509             r_cas_fsm       = CAS_BC_UPT_LOCK;
     5517            r_cas_fsm       = CAS_BC_IVT_LOCK;
    55105518          }
    55115519          else
     
    55225530    }
    55235531    /////////////////////
    5524     case CAS_BC_UPT_LOCK:  // register a broadcast inval transaction in UPT
     5532    case CAS_BC_IVT_LOCK:  // register a broadcast inval transaction in IVT
    55255533                           // write data in cache in case of successful registration
    55265534    {
    5527       if(r_alloc_upt_fsm.read() == ALLOC_UPT_CAS)
     5535      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS)
    55285536      {
    55295537        bool        wok       = false;
     
    55355543        size_t      nb_copies = r_cas_count.read();
    55365544
    5537         // register a broadcast inval transaction in UPT
    5538         wok = m_upt.set(false,  // it's an inval transaction
    5539                         true,    // it's a broadcast
    5540                         true,    // response required
    5541                         false,   // no acknowledge required
     5545        // register a broadcast inval transaction in IVT
     5546        wok = m_ivt.set(false,  // it's an inval transaction
     5547                        true,   // it's a broadcast
     5548                        true,   // response required
     5549                        false,  // no acknowledge required
    55425550                        srcid,
    55435551                        trdid,
     
    55475555                        index);
    55485556
    5549         if(wok)     // UPT not full
     5557        if(wok)     // IVT not full
    55505558        {
    55515559          // cache update
     
    55735581if(m_debug)
    55745582std::cout << "  <MEMC " << name()
    5575           << " CAS_BC_UPT_LOCK> Register a broadcast inval transaction in UPT"
     5583          << " CAS_BC_IVT_LOCK> Register a broadcast inval transaction in IVT"
    55765584          << " / nline = " << std::hex << nline
    55775585          << " / count = " << std::dec << nb_copies
    5578           << " / upt_index = " << index << std::endl;
    5579 #endif
    5580         }
    5581         else      //  releases the lock protecting UPT
     5586          << " / ivt_index = " << index << std::endl;
     5587#endif
     5588        }
     5589        else      //  releases the lock protecting IVT
    55825590        {
    55835591          r_cas_fsm = CAS_WAIT;
     
    55905598    {
    55915599      if((r_alloc_trt_fsm.read() == ALLOC_TRT_CAS) and
    5592           (r_alloc_upt_fsm.read() == ALLOC_UPT_CAS) and
    5593           (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
     5600         (r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS) and
     5601         (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
    55945602      {
    55955603        // set TRT
     
    58345842  // network, used to update or invalidate cache lines in L1 caches.
    58355843  //
    5836   // This fsm is used also to acknowledge CLEANUP a command after request from
    5837   // the CLEANUP fsm.
    5838   //
    5839   // It implements a round-robin priority between the five possible client FSMs
    5840   //     XRAM_RSP > CAS > CLEANUP > WRITE > CONFIG
     5844  // It implements a round-robin priority between the four possible client FSMs
     5845  //     XRAM_RSP > CAS > WRITE > CONFIG
    58415846  //
    58425847  // Each FSM can request the next services:
     
    58505855  //   r_config_to_cc_send_brdcast_req : broadcast-inval
    58515856  //   
    5852   // - r_cleanup_to_cc_send_req : cleanup acknowledgement
    5853   //
    58545857  // An inval request is a double DSPIN flit command containing:
    58555858  // 1. the index of the line to be invalidated.
     
    58945897          break;
    58955898        }
    5896         // CLEANUP
    5897         if (r_cleanup_to_cc_send_req.read())
    5898         {
    5899           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    5900           break;
    5901         }
    59025899        // WRITE
    59035900        if(m_write_to_cc_send_inst_fifo.rok() or
     
    59735970          break;
    59745971        }
    5975         // CLEANUP
    5976         if (r_cleanup_to_cc_send_req.read())
    5977         {
    5978           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    5979           break;
    5980         }
    59815972        // WRITE
    59825973        if(m_write_to_cc_send_inst_fifo.rok() or
     
    60126003          break;
    60136004        }
    6014         // CLEANUP
    6015         if(r_cleanup_to_cc_send_req.read())
    6016         {
    6017           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6018           break;
    6019         }
    60206005        // WRITE
    60216006        if(m_write_to_cc_send_inst_fifo.rok() or
     
    60656050      case CC_SEND_CAS_IDLE:   // CLEANUP FSM has highest priority
    60666051      {
    6067         if(r_cleanup_to_cc_send_req.read())
    6068         {
    6069           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6070           break;
    6071         }
    60726052        if(m_write_to_cc_send_inst_fifo.rok() or
    60736053            r_write_to_cc_send_multi_req.read())
     
    61246104        break;
    61256105      }
    6126       //////////////////////////
    6127       case CC_SEND_CLEANUP_IDLE:   // WRITE FSM has highest priority
    6128       {
    6129         // WRITE
    6130         if(m_write_to_cc_send_inst_fifo.rok() or
    6131             r_write_to_cc_send_multi_req.read())
    6132         {
    6133           r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6134           m_cpt_update++;
    6135           break;
    6136         }
    6137         if(r_write_to_cc_send_brdcast_req.read())
    6138         {
    6139           r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6140           m_cpt_inval++;
    6141           break;
    6142         }
    6143         // CONFIG
    6144         if(r_config_to_cc_send_multi_req.read())
    6145         {
    6146           r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6147           m_cpt_inval++;
    6148           break;
    6149         }
    6150         if(r_config_to_cc_send_brdcast_req.read())
    6151         {
    6152           r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6153           m_cpt_inval++;
    6154           break;
    6155         }
    6156         // XRAM_RSP
    6157         if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    6158             r_xram_rsp_to_cc_send_multi_req.read())
    6159         {
    6160           r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6161           m_cpt_inval++;
    6162           break;
    6163         }
    6164         if(r_xram_rsp_to_cc_send_brdcast_req.read())
    6165         {
    6166           r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6167           m_cpt_inval++;
    6168           break;
    6169         }
    6170         // CAS
    6171         if(m_cas_to_cc_send_inst_fifo.rok() or
    6172             r_cas_to_cc_send_multi_req.read())
    6173         {
    6174           r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6175           m_cpt_update++;
    6176           break;
    6177         }
    6178         if(r_cas_to_cc_send_brdcast_req.read())
    6179         {
    6180           r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6181           m_cpt_inval++;
    6182           break;
    6183         }
    6184         // CLEANUP
    6185         if(r_cleanup_to_cc_send_req.read())
    6186         {
    6187           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6188           break;
    6189         }
    6190         break;
    6191       }
    61926106      /////////////////////////////////
    61936107      case CC_SEND_CONFIG_INVAL_HEADER:   // send first flit multi-inval (from CONFIG FSM)
     
    61956109        if(m_config_to_cc_send_inst_fifo.rok())
    61966110        {
    6197           if(not p_dspin_out.read) break;
     6111          if(not p_dspin_m2p.read) break;
    61986112          r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    61996113          break;
     
    62066120      case CC_SEND_CONFIG_INVAL_NLINE:    // send second flit multi-inval (from CONFIG FSM)
    62076121      {
    6208         if(not p_dspin_out.read) break;
     6122        if(not p_dspin_m2p.read) break;
    62096123        m_cpt_inval_mult++;
    62106124        config_to_cc_send_fifo_get = true;
     
    62226136      case CC_SEND_CONFIG_BRDCAST_HEADER:   // send first flit BC-inval (from CONFIG FSM)
    62236137      {
    6224         if(not p_dspin_out.read) break;
     6138        if(not p_dspin_m2p.read) break;
    62256139        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_NLINE;
    62266140        break;
     
    62296143      case CC_SEND_CONFIG_BRDCAST_NLINE:    // send second flit BC-inval (from CONFIG FSM)
    62306144      {
    6231         if(not p_dspin_out.read) break;
     6145        if(not p_dspin_m2p.read) break;
    62326146        m_cpt_inval_brdcast++;
    62336147        r_config_to_cc_send_brdcast_req = false;
     
    62426156        break;
    62436157      }
    6244       /////////////////////////
    6245       case CC_SEND_CLEANUP_ACK:   // send one flit for a cleanup acknowledgement
    6246       {
    6247         if(not p_dspin_out.read) break;
    6248 
    6249         r_cleanup_to_cc_send_req = false;
    6250         r_cc_send_fsm = CC_SEND_CLEANUP_IDLE;
    6251 
    6252 #if DEBUG_MEMC_CC_SEND
    6253 if(m_debug)
    6254 std::cout << "  <MEMC " << name()
    6255           << " CC_SEND_CLEANUP_ACK> Cleanup Ack for srcid "
    6256           << std::hex << r_cleanup_to_cc_send_srcid.read() << std::endl;
    6257 #endif
    6258         break;
    6259       }
    62606158      ///////////////////////////////////
    62616159      case CC_SEND_XRAM_RSP_INVAL_HEADER:   // send first flit multi-inval (from XRAM_RSP FSM)
     
    62636161        if(m_xram_rsp_to_cc_send_inst_fifo.rok())
    62646162        {
    6265           if(not p_dspin_out.read) break;
     6163          if(not p_dspin_m2p.read) break;
    62666164          r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    62676165          break;
     
    62746172      case CC_SEND_XRAM_RSP_INVAL_NLINE:   // send second flit multi-inval (from XRAM_RSP FSM)
    62756173      {
    6276         if(not p_dspin_out.read) break;
     6174        if(not p_dspin_m2p.read) break;
    62776175        m_cpt_inval_mult++;
    62786176        xram_rsp_to_cc_send_fifo_get = true;
     
    62826180if(m_debug)
    62836181std::cout << "  <MEMC " << name()
    6284           << " CC_SEND_XRAM_RSP_INVAL_NLINE> BC-Inval for line "
     6182          << " CC_SEND_XRAM_RSP_INVAL_NLINE> Multicast-Inval for line "
    62856183          << std::hex << r_xram_rsp_to_cc_send_nline.read() << std::endl;
    62866184#endif
     
    62906188      case CC_SEND_XRAM_RSP_BRDCAST_HEADER:  // send first flit broadcast-inval (from XRAM_RSP FSM)
    62916189      {
    6292         if(not p_dspin_out.read) break;
     6190        if(not p_dspin_m2p.read) break;
    62936191        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_NLINE;
    62946192        break;
     
    62976195      case CC_SEND_XRAM_RSP_BRDCAST_NLINE:   // send second flit broadcast-inval (from XRAM_RSP FSM)
    62986196      {
    6299         if(not p_dspin_out.read) break;
     6197        if(not p_dspin_m2p.read) break;
    63006198        m_cpt_inval_brdcast++;
    63016199        r_xram_rsp_to_cc_send_brdcast_req = false;
     
    63136211      case CC_SEND_WRITE_BRDCAST_HEADER:   // send first flit broadcast-inval (from WRITE FSM)
    63146212      {
    6315         if(not p_dspin_out.read) break;
     6213        if(not p_dspin_m2p.read) break;
    63166214        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_NLINE;
    63176215        break;
     
    63206218      case CC_SEND_WRITE_BRDCAST_NLINE:   // send second flit broadcast-inval (from WRITE FSM)
    63216219      {
    6322         if(not p_dspin_out.read) break;
     6220        if(not p_dspin_m2p.read) break;
    63236221
    63246222        m_cpt_inval_brdcast++;
     
    63406238        if(m_write_to_cc_send_inst_fifo.rok())
    63416239        {
    6342           if(not p_dspin_out.read) break;
     6240          if(not p_dspin_m2p.read) break;
    63436241
    63446242          r_cc_send_fsm = CC_SEND_WRITE_UPDT_NLINE;
     
    63576255      case CC_SEND_WRITE_UPDT_NLINE:   // send second flit for a multi-update (from WRITE FSM)
    63586256      {
    6359         if(not p_dspin_out.read) break;
     6257        if(not p_dspin_m2p.read) break;
    63606258        m_cpt_update_mult++;
    63616259
     
    63746272      case CC_SEND_WRITE_UPDT_DATA:   // send N data flits for a multi-update (from WRITE FSM)
    63756273      {
    6376         if(not p_dspin_out.read) break;
     6274        if(not p_dspin_m2p.read) break;
    63776275        if(r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1))
    63786276        {
     
    63886286      case CC_SEND_CAS_BRDCAST_HEADER:   // send first flit  broadcast-inval (from CAS FSM)
    63896287      {
    6390         if(not p_dspin_out.read) break;
     6288        if(not p_dspin_m2p.read) break;
    63916289        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_NLINE;
    63926290        break;
     
    63956293      case CC_SEND_CAS_BRDCAST_NLINE:   // send second flit broadcast-inval (from CAS FSM)
    63966294      {
    6397         if(not p_dspin_out.read) break;
     6295        if(not p_dspin_m2p.read) break;
    63986296        m_cpt_inval_brdcast++;
    63996297
     
    64146312        if(m_cas_to_cc_send_inst_fifo.rok())
    64156313        {
    6416           if(not p_dspin_out.read) break;
     6314          if(not p_dspin_m2p.read) break;
    64176315
    64186316          r_cc_send_fsm = CC_SEND_CAS_UPDT_NLINE;
     
    64326330      case CC_SEND_CAS_UPDT_NLINE:   // send second flit for a multi-update (from CAS FSM)
    64336331      {
    6434         if(not p_dspin_out.read) break;
     6332        if(not p_dspin_m2p.read) break;
    64356333
    64366334        m_cpt_update_mult++;
     
    64506348      case CC_SEND_CAS_UPDT_DATA:   // send first data for a multi-update (from CAS FSM)
    64516349      {
    6452         if(not p_dspin_out.read) break;
     6350        if(not p_dspin_m2p.read) break;
    64536351
    64546352        if(r_cas_to_cc_send_is_long.read())
     
    64656363      case CC_SEND_CAS_UPDT_DATA_HIGH:   // send second data for a multi-update (from CAS FSM)
    64666364      {
    6467         if(not p_dspin_out.read) break;
     6365        if(not p_dspin_m2p.read) break;
    64686366        cas_to_cc_send_fifo_get = true;
    64696367        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
     
    64856383    case CC_RECEIVE_IDLE:
    64866384      {
    6487         if(not p_dspin_in.write) break;
     6385        if(not p_dspin_p2m.write) break;
    64886386
    64896387        uint8_t type =
    64906388          DspinDhccpParam::dspin_get(
    6491               p_dspin_in.data.read(),
    6492               DspinDhccpParam::FROM_L1_TYPE);
     6389              p_dspin_p2m.data.read(),
     6390              DspinDhccpParam::P2M_TYPE);
    64936391
    64946392        if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
     
    65166414        // write first CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    65176415
    6518         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     6416        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    65196417          break;
    65206418
    6521         assert(not p_dspin_in.eop.read() and
     6419        assert(not p_dspin_p2m.eop.read() and
    65226420            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65236421            "CLEANUP command must have two flits");
     
    65336431        // write second CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    65346432
    6535         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     6433        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    65366434          break;
    65376435
    6538         assert(p_dspin_in.eop.read() and
     6436        assert(p_dspin_p2m.eop.read() and
    65396437            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65406438            "CLEANUP command must have two flits");
     
    65526450
    65536451        // wait for a WOK in the CC_RECEIVE to MULTI_ACK fifo
    6554         if(not p_dspin_in.write or not m_cc_receive_to_multi_ack_fifo.wok())
     6452        if(not p_dspin_p2m.write or not m_cc_receive_to_multi_ack_fifo.wok())
    65556453          break;
    65566454
    6557         assert(p_dspin_in.eop.read() and
     6455        assert(p_dspin_p2m.eop.read() and
    65586456            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65596457            "MULTI_ACK command must have one flit");
     
    69656863  //    ALLOC_UPT FSM
    69666864  ////////////////////////////////////////////////////////////////////////////////////
    6967   // The ALLOC_UPT FSM allocates the access to the Update/Inval Table (UPT),
    6968   // with a round robin priority between six FSMs, with the following order:
    6969   //  CONFIG > MULTI_ACK > WRITE > XRAM_RSP > CLEANUP > CAS
    6970   // - The CONFIG FSM initiates an inval transaction and sets a new entry in UPT.
     6865  // The ALLOC_UPT FSM allocates the access to the Update Table (UPT),
     6866  // with a round robin priority between three FSMs, with the following order:
     6867  //  WRITE -> CAS -> MULTI_ACK
     6868  // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
     6869  // - The CAS FSM does the same thing as the WRITE FSM.
    69716870  // - The MULTI_ACK FSM complete those trasactions and erase the UPT entry.
    6972   // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
    6973   // - The XRAM_RSP FSM initiates an inval transactions and sets a new entry in UPT.
    6974   // - The CLEANUP  FSM decrement an entry in UPT.
    6975   // - The CAS FSM does the same thing as the WRITE FSM.
    69766871  // The resource is always allocated.
    69776872  /////////////////////////////////////////////////////////////////////////////////////
    6978 
    69796873  switch(r_alloc_upt_fsm.read())
    69806874  {
    6981       //////////////////////
    6982       case ALLOC_UPT_CONFIG:   // allocated to CONFIG FSM
    6983       if (r_config_fsm.read() != CONFIG_DIR_UPT_LOCK)
    6984       {
    6985         if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    6986           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    6987                
    6988         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    6989                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    6990           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    6991 
    6992         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    6993           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    6994 
    6995         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    6996           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    6997 
    6998         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    6999                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7000           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7001       }
    7002       break;
    7003 
    70046875      /////////////////////////
    7005       case ALLOC_UPT_MULTI_ACK:   // allocated to MULTI_ACK FSM
    7006       if( (r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK) and
    7007           (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
    7008       {
    7009         if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7010             (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7011           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7012 
    7013         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7014           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7015 
    7016         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7017           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7018 
    7019         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7020                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7021           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7022 
    7023         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7024           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7025       }
    7026       break;
    7027 
    7028       /////////////////////
    7029       case ALLOC_UPT_WRITE:   // allocated to WRITE FSM
    7030       if((r_write_fsm.read() != WRITE_UPT_LOCK) and
    7031           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
    7032       {
    7033         if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7034           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7035 
    7036         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7037           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7038 
    7039         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7040                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7041           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7042 
    7043         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7044           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7045 
    7046         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7047           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7048       }
    7049       break;
    7050 
    7051       ////////////////////////
    7052       case ALLOC_UPT_XRAM_RSP:
    7053       if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
    7054       {
    7055         if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7056           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7057 
    7058         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7059                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7060           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7061 
    7062         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7063           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7064 
    7065         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7066           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7067 
    7068         else if((r_write_fsm.read() == WRITE_UPT_LOCK)   or
    7069                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7070           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7071       }
    7072       break;
    7073 
     6876      case ALLOC_UPT_WRITE:         // allocated to WRITE FSM
     6877          if (r_write_fsm.read() != WRITE_UPT_LOCK)
     6878          {
     6879              if (r_cas_fsm.read() == CAS_UPT_LOCK)
     6880                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6881
     6882              else if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6883                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     6884          }
     6885          break;
     6886
     6887      /////////////////////////
     6888      case ALLOC_UPT_CAS:           // allocated to CAS FSM
     6889          if (r_cas_fsm.read() != CAS_UPT_LOCK)
     6890          {
     6891              if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6892                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     6893
     6894              else if (r_write_fsm.read() == WRITE_UPT_LOCK)
     6895                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     6896          }
     6897          break;
     6898
     6899      /////////////////////////
     6900      case ALLOC_UPT_MULTI_ACK:     // allocated to MULTI_ACK FSM
     6901          if ((r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK ) and
     6902              (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
     6903          {
     6904              if (r_write_fsm.read() == WRITE_UPT_LOCK)
     6905                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     6906
     6907              else if (r_cas_fsm.read() == CAS_UPT_LOCK)
     6908                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6909          }
     6910          break;
     6911  } // end switch r_alloc_upt_fsm
     6912
     6913  ////////////////////////////////////////////////////////////////////////////////////
     6914  //    ALLOC_IVT FSM
     6915  ////////////////////////////////////////////////////////////////////////////////////
     6916  // The ALLOC_IVT FSM allocates the access to the Invalidate Table (IVT),
     6917  // with a round robin priority between five FSMs, with the following order:
     6918  //  WRITE -> XRAM_RSP -> CLEANUP -> CAS -> CONFIG
     6919  // - The WRITE FSM initiates broadcast invalidate transactions and sets a new entry
     6920  //   in IVT.
     6921  // - The CAS FSM does the same thing as the WRITE FSM.
     6922  // - The XRAM_RSP FSM initiates broadcast/multicast invalidate transaction and sets
     6923  //   a new entry in the IVT
     6924  // - The CONFIG FSM does the same thing as the XRAM_RSP FSM
     6925  // - The CLEANUP FSM complete those trasactions and erase the IVT entry.
     6926  // The resource is always allocated.
     6927  /////////////////////////////////////////////////////////////////////////////////////
     6928  switch(r_alloc_ivt_fsm.read())
     6929  {
    70746930      //////////////////////////
    7075       case ALLOC_UPT_CLEANUP:
    7076       if((r_cleanup_fsm.read() != CLEANUP_UPT_LOCK     ) and
    7077          (r_cleanup_fsm.read() != CLEANUP_UPT_DECREMENT))
    7078       {
    7079         if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7080             (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7081           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7082 
    7083         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7084           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7085 
    7086         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7087           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7088 
    7089         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7090                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7091           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7092 
    7093         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7094           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7095       }
    7096       break;
     6931      case ALLOC_IVT_WRITE:            // allocated to WRITE FSM
     6932          if (r_write_fsm.read() != WRITE_BC_IVT_LOCK)
     6933          {
     6934              if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6935                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     6936
     6937              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     6938                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     6939
     6940              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     6941                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     6942
     6943              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6944                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6945          }
     6946          break;
    70976947
    70986948      //////////////////////////
    7099       case ALLOC_UPT_CAS:
    7100       if((r_cas_fsm.read() != CAS_UPT_LOCK) and
    7101           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
    7102       {
    7103         if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7104           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7105 
    7106         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7107           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7108 
    7109         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7110                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7111           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7112 
    7113         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7114           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7115 
    7116         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7117           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7118       }
    7119       break;
    7120 
    7121   } // end switch r_alloc_upt_fsm
     6949      case ALLOC_IVT_XRAM_RSP:         // allocated to XRAM_RSP FSM
     6950          if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
     6951          {
     6952              if(r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     6953                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     6954
     6955              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     6956                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     6957
     6958              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6959                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6960
     6961              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     6962                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     6963          }
     6964          break;
     6965
     6966      //////////////////////////
     6967      case ALLOC_IVT_CLEANUP:          // allocated to CLEANUP FSM
     6968          if ((r_cleanup_fsm.read() != CLEANUP_IVT_LOCK     ) and
     6969              (r_cleanup_fsm.read() != CLEANUP_IVT_DECREMENT))
     6970          {
     6971              if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     6972                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     6973
     6974              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6975                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6976
     6977              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     6978                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     6979
     6980              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6981                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     6982          }
     6983          break;
     6984
     6985      //////////////////////////
     6986      case ALLOC_IVT_CAS:              // allocated to CAS FSM
     6987          if (r_cas_fsm.read() != CAS_BC_IVT_LOCK)
     6988          {
     6989              if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6990                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6991
     6992              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     6993                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     6994
     6995              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6996                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     6997
     6998              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     6999                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7000          }
     7001          break;
     7002
     7003      //////////////////////////
     7004      case ALLOC_IVT_CONFIG:           // allocated to CONFIG FSM
     7005          if (r_config_fsm.read() != CONFIG_DIR_IVT_LOCK)
     7006          {
     7007              if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7008                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7009
     7010              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7011                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7012
     7013              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7014                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7015
     7016              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7017                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7018          }
     7019          break;
     7020
     7021  } // end switch r_alloc_ivt_fsm
    71227022
    71237023  ////////////////////////////////////////////////////////////////////////////////////
     
    71497049    if ( (r_config_fsm.read()    != CONFIG_DIR_REQ) and
    71507050         (r_config_fsm.read()    != CONFIG_DIR_ACCESS) and
    7151          (r_config_fsm.read()    != CONFIG_DIR_UPT_LOCK) )
     7051         (r_config_fsm.read()    != CONFIG_DIR_IVT_LOCK) )
    71527052    {
    71537053        if(r_read_fsm.read() == READ_DIR_REQ)
     
    72027102        (r_write_fsm.read()       != WRITE_DIR_HIT)  and
    72037103        (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  and
    7204         (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  and
     7104        (r_write_fsm.read()       != WRITE_BC_IVT_LOCK)  and
    72057105        (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  and
    72067106        (r_write_fsm.read()       != WRITE_UPT_LOCK)  and
     
    72387138        (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  and
    72397139        (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  and
    7240         (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  and
     7140        (r_cas_fsm.read()         != CAS_BC_IVT_LOCK)  and
    72417141        (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  and
    72427142        (r_cas_fsm.read()         != CAS_UPT_LOCK)  and
     
    73527252      if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
    73537253          (r_write_fsm.read() != WRITE_BC_TRT_LOCK) and
    7354           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
     7254          (r_write_fsm.read() != WRITE_BC_IVT_LOCK))
    73557255      {
    73567256        if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
     
    73757275      if((r_cas_fsm.read() != CAS_MISS_TRT_LOCK) and
    73767276          (r_cas_fsm.read() != CAS_BC_TRT_LOCK) and
    7377           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
     7277          (r_cas_fsm.read() != CAS_BC_IVT_LOCK))
    73787278      {
    73797279        if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     
    76657565  m_cc_receive_to_cleanup_fifo.update( cc_receive_to_cleanup_fifo_get,
    76667566                                       cc_receive_to_cleanup_fifo_put,
    7667                                        p_dspin_in.data.read() );
     7567                                       p_dspin_p2m.data.read() );
    76687568
    76697569  ////////////////////////////////////////////////////////////////////////////////////
     
    76737573  m_cc_receive_to_multi_ack_fifo.update( cc_receive_to_multi_ack_fifo_get,
    76747574                                         cc_receive_to_multi_ack_fifo_put,
    7675                                          p_dspin_in.data.read() );
     7575                                         p_dspin_p2m.data.read() );
    76767576
    76777577  ////////////////////////////////////////////////////////////////////////////////////
     
    80157915
    80167916  ////////////////////////////////////////////////////////////////////
    8017   //  p_dspin_out port (CC_SEND FSM)
     7917  //  p_dspin_m2p port (CC_SEND FSM)
    80187918  ////////////////////////////////////////////////////////////////////
    80197919
    8020   p_dspin_out.write = false;
    8021   p_dspin_out.eop   = false;
    8022   p_dspin_out.data  = 0;
     7920  p_dspin_m2p.write = false;
     7921  p_dspin_m2p.eop   = false;
     7922  p_dspin_m2p.data  = 0;
    80237923
    80247924  switch(r_cc_send_fsm.read())
     
    80297929    case CC_SEND_WRITE_IDLE:
    80307930    case CC_SEND_CAS_IDLE:
    8031     case CC_SEND_CLEANUP_IDLE:
    80327931    {
    80337932        break;
     
    80647963        DspinDhccpParam::dspin_set( flit,
    80657964                                    multi_inval_type,
    8066                                     DspinDhccpParam::FROM_MC_TYPE);
    8067         p_dspin_out.write = true;
    8068         p_dspin_out.data  = flit;
     7965                                    DspinDhccpParam::M2P_TYPE);
     7966        p_dspin_m2p.write = true;
     7967        p_dspin_m2p.data  = flit;
    80697968        break;
    80707969    }
     
    80767975                                    r_config_to_cc_send_nline.read(),
    80777976                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8078         p_dspin_out.eop   = true;
    8079         p_dspin_out.write = true;
    8080         p_dspin_out.data  = flit;
     7977        p_dspin_m2p.eop   = true;
     7978        p_dspin_m2p.write = true;
     7979        p_dspin_m2p.data  = flit;
    80817980        break;
    80827981    }
    8083     ////////////////////////
    8084     case CC_SEND_CLEANUP_ACK:
    8085       {
    8086         uint8_t cleanup_ack_type;
    8087         if(r_cleanup_to_cc_send_inst.read())
    8088         {
    8089           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_INST;
    8090         }
    8091         else
    8092         {
    8093           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_DATA;
    8094         }
    8095 
    8096         uint64_t flit = 0;
    8097         uint64_t dest =
    8098           r_cleanup_to_cc_send_srcid.read() <<
    8099           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8100 
    8101         DspinDhccpParam::dspin_set(
    8102             flit,
    8103             dest,
    8104             DspinDhccpParam::CLEANUP_ACK_DEST);
    8105 
    8106         DspinDhccpParam::dspin_set(
    8107             flit,
    8108             r_cleanup_to_cc_send_set_index.read(),
    8109             DspinDhccpParam::CLEANUP_ACK_SET);
    8110 
    8111         DspinDhccpParam::dspin_set(
    8112             flit,
    8113             r_cleanup_to_cc_send_way_index.read(),
    8114             DspinDhccpParam::CLEANUP_ACK_WAY);
    8115 
    8116         DspinDhccpParam::dspin_set(
    8117             flit,
    8118             cleanup_ack_type,
    8119             DspinDhccpParam::FROM_MC_TYPE);
    8120 
    8121         p_dspin_out.eop   = true;
    8122         p_dspin_out.write = true;
    8123         p_dspin_out.data  = flit;
    8124 
    8125         break;
    8126     }
    8127 
    81287982    ///////////////////////////////////
    81297983    case CC_SEND_XRAM_RSP_INVAL_HEADER:
     
    81598013        DspinDhccpParam::dspin_set( flit,
    81608014                                    multi_inval_type,
    8161                                     DspinDhccpParam::FROM_MC_TYPE);
    8162         p_dspin_out.write = true;
    8163         p_dspin_out.data  = flit;
     8015                                    DspinDhccpParam::M2P_TYPE);
     8016        p_dspin_m2p.write = true;
     8017        p_dspin_m2p.data  = flit;
    81648018        break;
    81658019    }
     
    81738027                                    r_xram_rsp_to_cc_send_nline.read(),
    81748028                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8175         p_dspin_out.eop   = true;
    8176         p_dspin_out.write = true;
    8177         p_dspin_out.data  = flit;
     8029        p_dspin_m2p.eop   = true;
     8030        p_dspin_m2p.write = true;
     8031        p_dspin_m2p.data  = flit;
    81788032        break;
    81798033    }
     
    81978051        DspinDhccpParam::dspin_set( flit,
    81988052                                    1ULL,
    8199                                     DspinDhccpParam::FROM_MC_BC);
    8200         p_dspin_out.write = true;
    8201         p_dspin_out.data  = flit;
     8053                                    DspinDhccpParam::M2P_BC);
     8054        p_dspin_m2p.write = true;
     8055        p_dspin_m2p.data  = flit;
    82028056        break;
    82038057    }
     
    82098063                                    r_xram_rsp_to_cc_send_nline.read(),
    82108064                                    DspinDhccpParam::BROADCAST_NLINE);
    8211         p_dspin_out.write = true;
    8212         p_dspin_out.eop   = true;
    8213         p_dspin_out.data  = flit;
     8065        p_dspin_m2p.write = true;
     8066        p_dspin_m2p.eop   = true;
     8067        p_dspin_m2p.data  = flit;
    82148068        break;
    82158069    }
     
    82218075                                    r_config_to_cc_send_nline.read(),
    82228076                                    DspinDhccpParam::BROADCAST_NLINE);
    8223         p_dspin_out.write = true;
    8224         p_dspin_out.eop   = true;
    8225         p_dspin_out.data  = flit;
     8077        p_dspin_m2p.write = true;
     8078        p_dspin_m2p.eop   = true;
     8079        p_dspin_m2p.data  = flit;
    82268080        break;
    82278081    }
     
    82338087                                    r_write_to_cc_send_nline.read(),
    82348088                                    DspinDhccpParam::BROADCAST_NLINE);
    8235         p_dspin_out.write = true;
    8236         p_dspin_out.eop   = true;
    8237         p_dspin_out.data  = flit;
     8089        p_dspin_m2p.write = true;
     8090        p_dspin_m2p.eop   = true;
     8091        p_dspin_m2p.data  = flit;
    82388092        break;
    82398093    }
     
    82458099                                    r_cas_to_cc_send_nline.read(),
    82468100                                    DspinDhccpParam::BROADCAST_NLINE);
    8247         p_dspin_out.write = true;
    8248         p_dspin_out.eop   = true;
    8249         p_dspin_out.data  = flit;
     8101        p_dspin_m2p.write = true;
     8102        p_dspin_m2p.eop   = true;
     8103        p_dspin_m2p.data  = flit;
    82508104        break;
    82518105    }
     
    82888142            flit,
    82898143            multi_updt_type,
    8290             DspinDhccpParam::FROM_MC_TYPE);
    8291 
    8292         p_dspin_out.write = true;
    8293         p_dspin_out.data  = flit;
     8144            DspinDhccpParam::M2P_TYPE);
     8145
     8146        p_dspin_m2p.write = true;
     8147        p_dspin_m2p.data  = flit;
    82948148
    82958149        break;
     
    83108164            DspinDhccpParam::MULTI_UPDT_NLINE);
    83118165
    8312         p_dspin_out.write = true;
    8313         p_dspin_out.data  = flit;
     8166        p_dspin_m2p.write = true;
     8167        p_dspin_m2p.data  = flit;
    83148168
    83158169        break;
     
    83378191            DspinDhccpParam::MULTI_UPDT_DATA);
    83388192
    8339         p_dspin_out.write = true;
    8340         p_dspin_out.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
    8341         p_dspin_out.data  = flit;
     8193        p_dspin_m2p.write = true;
     8194        p_dspin_m2p.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
     8195        p_dspin_m2p.data  = flit;
    83428196
    83438197        break;
     
    83818235            flit,
    83828236            multi_updt_type,
    8383             DspinDhccpParam::FROM_MC_TYPE);
    8384 
    8385         p_dspin_out.write = true;
    8386         p_dspin_out.data  = flit;
     8237            DspinDhccpParam::M2P_TYPE);
     8238
     8239        p_dspin_m2p.write = true;
     8240        p_dspin_m2p.data  = flit;
    83878241
    83888242        break;
     
    84038257            DspinDhccpParam::MULTI_UPDT_NLINE);
    84048258
    8405         p_dspin_out.write = true;
    8406         p_dspin_out.data  = flit;
     8259        p_dspin_m2p.write = true;
     8260        p_dspin_m2p.data  = flit;
    84078261
    84088262        break;
     
    84238277            DspinDhccpParam::MULTI_UPDT_DATA);
    84248278
    8425         p_dspin_out.write = true;
    8426         p_dspin_out.eop   = not r_cas_to_cc_send_is_long.read();
    8427         p_dspin_out.data  = flit;
     8279        p_dspin_m2p.write = true;
     8280        p_dspin_m2p.eop   = not r_cas_to_cc_send_is_long.read();
     8281        p_dspin_m2p.data  = flit;
    84288282
    84298283        break;
     
    84448298            DspinDhccpParam::MULTI_UPDT_DATA);
    84458299
    8446         p_dspin_out.write = true;
    8447         p_dspin_out.eop   = true;
    8448         p_dspin_out.data  = flit;
     8300        p_dspin_m2p.write = true;
     8301        p_dspin_m2p.eop   = true;
     8302        p_dspin_m2p.data  = flit;
    84498303
    84508304        break;
     
    84528306  }
    84538307
     8308  ////////////////////////////////////////////////////////////////////
     8309  //  p_dspin_clack port (CLEANUP FSM)
     8310  ////////////////////////////////////////////////////////////////////
     8311
     8312  switch(r_cleanup_fsm.read())
     8313  {
     8314    case CLEANUP_IDLE:
     8315    case CLEANUP_GET_NLINE:
     8316    case CLEANUP_DIR_REQ:
     8317    case CLEANUP_DIR_LOCK:
     8318    case CLEANUP_DIR_WRITE:
     8319    case CLEANUP_HEAP_REQ:
     8320    case CLEANUP_HEAP_LOCK:
     8321    case CLEANUP_HEAP_SEARCH:
     8322    case CLEANUP_HEAP_CLEAN:
     8323    case CLEANUP_HEAP_FREE:
     8324    case CLEANUP_IVT_LOCK:
     8325    case CLEANUP_IVT_DECREMENT:
     8326    case CLEANUP_IVT_CLEAR:
     8327    case CLEANUP_WRITE_RSP:
     8328    case CLEANUP_CONFIG_ACK:
     8329      p_dspin_clack.write = false;
     8330      p_dspin_clack.eop   = false;
     8331      p_dspin_clack.data  = 0;
     8332
     8333      break;
     8334
     8335    case CLEANUP_SEND_CLACK:
     8336      {
     8337        uint8_t cleanup_ack_type;
     8338        if(r_cleanup_inst.read())
     8339        {
     8340          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
     8341        }
     8342        else
     8343        {
     8344          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
     8345        }
     8346
     8347        uint64_t flit = 0;
     8348        uint64_t dest =
     8349          r_cleanup_srcid.read() <<
     8350          (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
     8351
     8352        DspinDhccpParam::dspin_set(
     8353            flit,
     8354            dest,
     8355            DspinDhccpParam::CLACK_DEST);
     8356
     8357        DspinDhccpParam::dspin_set(
     8358            flit,
     8359            r_cleanup_nline.read() & 0xFFFF,
     8360            DspinDhccpParam::CLACK_SET);
     8361
     8362        DspinDhccpParam::dspin_set(
     8363            flit,
     8364            r_cleanup_way_index.read(),
     8365            DspinDhccpParam::CLACK_WAY);
     8366
     8367        DspinDhccpParam::dspin_set(
     8368            flit,
     8369            cleanup_ack_type,
     8370            DspinDhccpParam::CLACK_TYPE);
     8371
     8372        p_dspin_clack.eop   = true;
     8373        p_dspin_clack.write = true;
     8374        p_dspin_clack.data  = flit;
     8375      }
     8376      break;
     8377  }
     8378
    84548379  ///////////////////////////////////////////////////////////////////
    8455   //  p_dspin_in port (CC_RECEIVE FSM)
     8380  //  p_dspin_p2m port (CC_RECEIVE FSM)
    84568381  ///////////////////////////////////////////////////////////////////
    8457   p_dspin_in.read = false;
     8382  //
    84588383  switch(r_cc_receive_fsm.read())
    84598384  {
    84608385    case CC_RECEIVE_IDLE:
    84618386      {
     8387        p_dspin_p2m.read = false;
    84628388        break;
    84638389      }
     
    84658391    case CC_RECEIVE_CLEANUP_EOP:
    84668392      {
    8467         p_dspin_in.read = m_cc_receive_to_cleanup_fifo.wok();
     8393        p_dspin_p2m.read = m_cc_receive_to_cleanup_fifo.wok();
    84688394        break;
    84698395      }
    84708396    case CC_RECEIVE_MULTI_ACK:
    84718397      {
    8472         p_dspin_in.read = m_cc_receive_to_multi_ack_fifo.wok();
     8398        p_dspin_p2m.read = m_cc_receive_to_multi_ack_fifo.wok();
    84738399        break;
    84748400      }
Note: See TracChangeset for help on using the changeset viewer.