Ignore:
Timestamp:
Jul 29, 2013, 11:31:38 AM (11 years ago)
Author:
devigne
Message:

Merge with the lastest version of Trunk
Modification in vci_mem_cache : Using TRT's wdata field for
put request to ixr_cmd (just for INCLUSIVE mode)

Location:
branches/ODCCP/modules/vci_mem_cache
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • branches/ODCCP/modules/vci_mem_cache

  • branches/ODCCP/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd

    r434 r479  
    4949            Port('caba:vci_initiator', 'p_vci_ixr'),
    5050            Port('caba:dspin_input',
    51                 'p_dspin_in',
     51                'p_dspin_p2m',
    5252                dspin_data_size = parameter.Reference('dspin_in_width')
    5353            ),
    5454            Port('caba:dspin_output',
    55                 'p_dspin_out',
     55                'p_dspin_m2p',
     56                dspin_data_size = parameter.Reference('dspin_out_width')
     57            ),
     58            Port('caba:dspin_output',
     59                'p_dspin_clack',
    5660                dspin_data_size = parameter.Reference('dspin_out_width')
    5761            ),

  • branches/ODCCP/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r460 r479  
    5454#define TRT_ENTRIES      4      // Number of entries in TRT
    5555#define UPT_ENTRIES      4      // Number of entries in UPT
     56#define IVT_ENTRIES      4      // Number of entries in IVT
    5657#define HEAP_ENTRIES     1024   // Number of entries in HEAP
    5758
    … …  
    122123        CC_SEND_WRITE_IDLE,
    123124        CC_SEND_CAS_IDLE,
    124         CC_SEND_CLEANUP_IDLE,
    125125        CC_SEND_CONFIG_INVAL_HEADER,
    126126        CC_SEND_CONFIG_INVAL_NLINE,
    127127        CC_SEND_CONFIG_BRDCAST_HEADER,
    128128        CC_SEND_CONFIG_BRDCAST_NLINE,
    129         CC_SEND_CLEANUP_ACK,
    130129        CC_SEND_XRAM_RSP_BRDCAST_HEADER,
    131130        CC_SEND_XRAM_RSP_BRDCAST_NLINE,
    … …  
    163162        CONFIG_DIR_REQ,
    164163        CONFIG_DIR_ACCESS,
    165         CONFIG_DIR_UPT_LOCK,
     164        CONFIG_DIR_IVT_LOCK,
    166165        CONFIG_BC_SEND,
    167166        CONFIG_BC_WAIT,
    … …  
    211210        WRITE_MISS_XRAM_REQ,
    212211        WRITE_BC_TRT_LOCK,
    213         WRITE_BC_UPT_LOCK,
     212        WRITE_BC_IVT_LOCK,
    214213        WRITE_BC_DIR_INVAL,
    215214        WRITE_BC_CC_SEND,
    … …  
    255254        IXR_CMD_XRAM_IDLE,
    256255        IXR_CMD_CLEANUP_IDLE,
     256        IXR_CMD_TRT_LOCK,
    257257        IXR_CMD_READ,
    258258        IXR_CMD_WRITE,
    … …  
    276276        CAS_UPT_NEXT,
    277277        CAS_BC_TRT_LOCK,
    278         CAS_BC_UPT_LOCK,
     278        CAS_BC_IVT_LOCK,
    279279        CAS_BC_DIR_INVAL,
    280280        CAS_BC_CC_SEND,
    … …  
    302302        CLEANUP_HEAP_CLEAN,
    303303        CLEANUP_HEAP_FREE,
    304         CLEANUP_UPT_LOCK,
    305         CLEANUP_UPT_DECREMENT,
    306         CLEANUP_UPT_CLEAR,
     304        CLEANUP_IVT_LOCK,
     305        CLEANUP_IVT_DECREMENT,
     306        CLEANUP_IVT_CLEAR,
    307307        CLEANUP_WRITE_RSP,
    308308        CLEANUP_CONFIG_ACK,
    … …  
    332332        ALLOC_TRT_XRAM_RSP,
    333333        ALLOC_TRT_IXR_RSP,
    334         ALLOC_TRT_CLEANUP
     334        ALLOC_TRT_CLEANUP,
     335        ALLOC_TRT_IXR_CMD
    335336      };
    336337
    … …  
    338339      enum alloc_upt_fsm_state_e
    339340      {
    340         ALLOC_UPT_CONFIG,
    341341        ALLOC_UPT_WRITE,
    342         ALLOC_UPT_XRAM_RSP,
    343         ALLOC_UPT_MULTI_ACK,
    344         ALLOC_UPT_CLEANUP,
    345         ALLOC_UPT_CAS
     342        ALLOC_UPT_CAS,
     343        ALLOC_UPT_MULTI_ACK
     344      };
     345
     346      /* States of the ALLOC_IVT fsm */
     347      enum alloc_ivt_fsm_state_e
     348      {
     349        ALLOC_IVT_WRITE,
     350        ALLOC_IVT_XRAM_RSP,
     351        ALLOC_IVT_CLEANUP,
     352        ALLOC_IVT_CAS,
     353        ALLOC_IVT_CONFIG
    346354      };
    347355
    … …  
    492500      uint32_t     m_cpt_cas_fsm_upt_used;       // NB cycles UPT LOCK used
    493501     
    494       uint32_t     m_cpt_upt_unused;            // NB cycles UPT LOCK unused
     502      uint32_t     m_cpt_ivt_unused;            // NB cycles UPT LOCK unused
    495503
    496504      uint32_t     m_cpt_read_fsm_heap_lock;     // wait HEAP LOCK
    … …  
    536544      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
    537545      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
    538       soclib::caba::DspinInput<dspin_in_width>    p_dspin_in;
    539       soclib::caba::DspinOutput<dspin_out_width>  p_dspin_out;
     546      soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
     547      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
     548      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
    540549
    541550      VciMemCache(
    … …  
    553562          const size_t                       trt_lines=TRT_ENTRIES,
    554563          const size_t                       upt_lines=UPT_ENTRIES,     
     564          const size_t                       ivt_lines=IVT_ENTRIES,     
    555565          const size_t                       debug_start_cycle=0,
    556566          const bool                         debug_ok=false );
    … …  
    588598      TransactionTab                     m_trt;              // xram transaction table
    589599      uint32_t                           m_upt_lines;
    590       UpdateTab                          m_upt;              // pending update & invalidate
     600      UpdateTab                          m_upt;              // pending update
     601      UpdateTab                          m_ivt;              // pending invalidate
    591602      CacheDirectory                     m_cache_directory;  // data cache directory
    592603      CacheData                          m_cache_data;       // data array[set][way][word]
    … …  
    677688      sc_signal<size_t>   r_config_heap_next;      // current pointer to scan HEAP
    678689
    679       sc_signal<size_t>   r_config_upt_index;  // UPT index
     690      sc_signal<size_t>   r_config_ivt_index;      // IVT index
    680691
    681692      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
    … …  
    866877      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
    867878
    868       // Buffer between CLEANUP fsm and CC_SEND fsm (acknowledge a cleanup command from L1)
    869       sc_signal<bool>     r_cleanup_to_cc_send_req;       // valid request
    870       sc_signal<size_t>   r_cleanup_to_cc_send_srcid;     // L1 srcid
    871       sc_signal<size_t>   r_cleanup_to_cc_send_set_index; // L1 set index
    872       sc_signal<size_t>   r_cleanup_to_cc_send_way_index; // L1 way index
    873       sc_signal<bool>     r_cleanup_to_cc_send_inst;      // Instruction Cleanup Ack
    874 
    875879      ///////////////////////////////////////////////////////
    876880      // Registers controlled by CAS fsm
    … …  
    960964      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
    961965      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
    962       sc_signal<size_t>   r_xram_rsp_upt_index;         // UPT entry index
     966      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
    963967      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
    964968
    … …  
    10411045
    10421046      ////////////////////////////////////////////////////
     1047      // Registers controlled by ALLOC_IVT fsm
     1048      ////////////////////////////////////////////////////
     1049
     1050      sc_signal<int>      r_alloc_ivt_fsm;
     1051
     1052      ////////////////////////////////////////////////////
    10431053      // Registers controlled by ALLOC_HEAP fsm
    10441054      ////////////////////////////////////////////////////
    … …  
    10561066      sc_signal<uint32_t>  r_cleanup_pktid;
    10571067      sc_signal<data_t>    *r_cleanup_data;          // buffer for saving data from cleanup
     1068      sc_signal<data_t>    *r_ixr_cmd_data;          // buffer for saving data from cleanup
    10581069      sc_signal<bool>      r_cleanup_contains_data;
    10591070      sc_signal<bool>      r_cleanup_ncc;

  • branches/ODCCP/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r474 r479  
    102102  "CC_SEND_WRITE_IDLE",
    103103  "CC_SEND_CAS_IDLE",
    104   "CC_SEND_CLEANUP_IDLE",
    105104  "CC_SEND_CONFIG_INVAL_HEADER",
    106105  "CC_SEND_CONFIG_INVAL_NLINE",
    107106  "CC_SEND_CONFIG_BRDCAST_HEADER",
    108107  "CC_SEND_CONFIG_BRDCAST_NLINE",
    109   "CC_SEND_CLEANUP_ACK",
    110108  "CC_SEND_XRAM_RSP_BRDCAST_HEADER",
    111109  "CC_SEND_XRAM_RSP_BRDCAST_NLINE",
    … …  
    139137  "CONFIG_DIR_REQ",
    140138  "CONFIG_DIR_ACCESS",
    141   "CONFIG_DIR_UPT_LOCK",
     139  "CONFIG_DIR_IVT_LOCK",
    142140  "CONFIG_BC_SEND",
    143141  "CONFIG_BC_WAIT",
    … …  
    183181  "WRITE_MISS_XRAM_REQ",
    184182  "WRITE_BC_TRT_LOCK",
    185   "WRITE_BC_UPT_LOCK",
     183  "WRITE_BC_IVT_LOCK",
    186184  "WRITE_BC_DIR_INVAL",
    187185  "WRITE_BC_CC_SEND",
    … …  
    221219  "IXR_CMD_XRAM_IDLE",
    222220  "IXR_CMD_CLEANUP_IDLE",
     221  "IXR_CMD_TRT_LOCK",
    223222  "IXR_CMD_READ",
    224223  "IXR_CMD_WRITE",
    … …  
    240239  "CAS_UPT_NEXT",
    241240  "CAS_BC_TRT_LOCK",
    242   "CAS_BC_UPT_LOCK",
     241  "CAS_BC_IVT_LOCK",
    243242  "CAS_BC_DIR_INVAL",
    244243  "CAS_BC_CC_SEND",
    … …  
    264263  "CLEANUP_HEAP_CLEAN",
    265264  "CLEANUP_HEAP_FREE",
    266   "CLEANUP_UPT_LOCK",
    267   "CLEANUP_UPT_DECREMENT",
    268   "CLEANUP_UPT_CLEAR",
     265  "CLEANUP_IVT_LOCK",
     266  "CLEANUP_IVT_DECREMENT",
     267  "CLEANUP_IVT_CLEAR",
    269268  "CLEANUP_WRITE_RSP",
    270269  "CLEANUP_CONFIG_ACK",
    … …  
    290289  "ALLOC_TRT_XRAM_RSP",
    291290  "ALLOC_TRT_IXR_RSP",
    292   "ALLOC_TRT_CLEANUP"
     291  "ALLOC_TRT_CLEANUP",
     292  "ALLOC_TRT_IXR_CMD"
    293293};
    294294const char *alloc_upt_fsm_str[] =
    … …  
    296296  "ALLOC_UPT_CONFIG",
    297297  "ALLOC_UPT_WRITE",
    298   "ALLOC_UPT_XRAM_RSP",
    299   "ALLOC_UPT_MULTI_ACK",
    300   "ALLOC_UPT_CLEANUP",
    301   "ALLOC_UPT_CAS"
     298  "ALLOC_UPT_CAS",
     299  "ALLOC_UPT_MULTI_ACK"
     300};
     301const char *alloc_ivt_fsm_str[] =
     302{
     303  "ALLOC_IVT_WRITE",
     304  "ALLOC_IVT_XRAM_RSP",
     305  "ALLOC_IVT_CLEANUP",
     306  "ALLOC_IVT_CAS",
     307  "ALLOC_IVT_CONFIG"
    302308};
    303309const char *alloc_heap_fsm_str[] =
    … …  
    339345  const size_t        trt_lines,         // number of TRT entries
    340346  const size_t        upt_lines,         // number of UPT entries
     347  const size_t        ivt_lines,         // number of IVT entries
    341348  const size_t        debug_start_cycle,
    342349  const bool          debug_ok)
    … …  
    350357    p_vci_tgt( "p_vci_tgt" ),
    351358    p_vci_ixr( "p_vci_ixr" ),
    352     p_dspin_in( "p_dspin_in" ),
    353     p_dspin_out( "p_dspin_out" ),
     359    p_dspin_p2m( "p_dspin_p2m" ),
     360    p_dspin_m2p( "p_dspin_m2p" ),
     361    p_dspin_clack( "p_dspin_clack" ),
    354362
    355363    m_seglist( mtp.getSegmentList(tgtid_d) ),
    … …  
    368376    m_upt_lines(upt_lines),
    369377    m_upt(upt_lines),
     378    m_ivt(ivt_lines),
    370379    m_cache_directory(nways, nsets, nwords, vci_param_int::N),
    371380    m_cache_data(nways, nsets, nwords),
    … …  
    459468    r_alloc_trt_fsm("r_alloc_trt_fsm"),
    460469    r_alloc_upt_fsm("r_alloc_upt_fsm"),
     470    r_alloc_ivt_fsm("r_alloc_ivt_fsm"),
    461471    r_alloc_heap_fsm("r_alloc_heap_fsm"),
    462472    r_alloc_heap_reset_cpt("r_alloc_heap_reset_cpt")
    … …  
    534544    // Allocation for ODCCP
    535545    r_cleanup_data             = new sc_signal<data_t>[nwords];
     546    r_ixr_cmd_data             = new sc_signal<data_t>[nwords];
    536547    r_cleanup_to_ixr_cmd_data  = new sc_signal<data_t>[nwords];
    537548
    … …  
    641652            << " | " << ixr_cmd_fsm_str[r_ixr_cmd_fsm.read()]
    642653            << " | " << ixr_rsp_fsm_str[r_ixr_rsp_fsm.read()]
    643             << " | " << xram_rsp_fsm_str[r_xram_rsp_fsm] << std::endl;
     654            << " | " << xram_rsp_fsm_str[r_xram_rsp_fsm.read()] << std::endl;
    644655  std::cout << "  "  << alloc_dir_fsm_str[r_alloc_dir_fsm.read()]
    645656            << " | " << alloc_trt_fsm_str[r_alloc_trt_fsm.read()]
    646657            << " | " << alloc_upt_fsm_str[r_alloc_upt_fsm.read()]
     658            << " | " << alloc_ivt_fsm_str[r_alloc_ivt_fsm.read()]
    647659            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
    648660}
    … …  
    672684    m_cpt_trt_rb                  = 0;
    673685    m_cpt_dir_unused              = 0;
    674     m_cpt_upt_unused              = 0;
     686    m_cpt_ivt_unused              = 0;
    675687    m_cpt_heap_unused             = 0;
    676688    m_cpt_trt_unused              = 0;
    … …  
    771783      << "- WAIT UPT LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_upt_lock/m_cpt_cas_fsm_n_upt_lock << std::endl
    772784      << "- NB CYCLES IN UPT LOCK in CAS_FSM       = " << (double) m_cpt_cas_fsm_upt_used/m_cpt_cas_fsm_n_upt_lock << std::endl
    773       << "- UPT UNUSED RATE                        = " << (double) m_cpt_upt_unused/m_cpt_cycles << std::endl << std::endl
     785      << "- IVT UNUSED RATE                        = " << (double) m_cpt_ivt_unused/m_cpt_cycles << std::endl << std::endl
    774786     
    775787      << "- WAIT HEAP LOCK in READ_FSM             = " << (double) m_cpt_read_fsm_heap_lock/m_cpt_read_fsm_n_heap_lock << std::endl
    … …  
    805817
    806818  delete [] r_cleanup_data;
     819  delete [] r_ixr_cmd_data;
    807820  delete [] r_cleanup_to_ixr_cmd_data;
    808821}
    … …  
    833846    r_alloc_trt_fsm  = ALLOC_TRT_READ;
    834847    r_alloc_upt_fsm  = ALLOC_UPT_WRITE;
     848    r_alloc_ivt_fsm  = ALLOC_IVT_XRAM_RSP;
    835849    r_ixr_rsp_fsm    = IXR_RSP_IDLE;
    836850    r_xram_rsp_fsm   = XRAM_RSP_IDLE;
    … …  
    845859    m_trt.init();
    846860    m_upt.init();
     861    m_ivt.init();
    847862    m_llsc_table.init();
    848863
    … …  
    946961    r_cleanup_contains_data    = false;
    947962    r_cleanup_to_ixr_cmd_req   = false;
    948     r_cleanup_to_ixr_cmd_l1_dirty_ncc = false;
    949     r_xram_rsp_to_ixr_cmd_inval_ncc_pending = false;
     963    //r_cleanup_to_ixr_cmd_l1_dirty_ncc = false;
     964    //r_xram_rsp_to_ixr_cmd_inval_ncc_pending = false;
    950965    r_cleanup_to_ixr_cmd_srcid = 0;
    951966    r_cleanup_to_ixr_cmd_trdid = 0;
    … …  
    956971      r_cleanup_to_ixr_cmd_data[word] = 0;
    957972      r_cleanup_data[word] = 0;
     973      r_ixr_cmd_data[word] = 0;
    958974    }
    959975
    … …  
    980996    m_cpt_trt_rb                  = 0;
    981997    m_cpt_dir_unused              = 0;
    982     m_cpt_upt_unused              = 0;
     998    m_cpt_ivt_unused              = 0;
    983999    m_cpt_heap_unused             = 0;
    9841000    m_cpt_trt_unused              = 0;
    … …  
    17231739              r_config_dir_next_ptr   = entry.ptr;
    17241740
    1725               r_config_fsm    = CONFIG_DIR_UPT_LOCK;
     1741              r_config_fsm    = CONFIG_DIR_IVT_LOCK;
    17261742          }
    17271743          else if ( entry.valid and                       // hit & sync command
    … …  
    17521768      }
    17531769      /////////////////////////
    1754       case CONFIG_DIR_UPT_LOCK:  // enter this state in case of INVAL command
    1755                                  // Try to get both DIR & UPT locks, and return
    1756                                  // to LOOP state if UPT full.
    1757                                  // Register inval in UPT, and invalidate the
    1758                                  // directory if UPT not full.
    1759       {
    1760           if ( r_alloc_upt_fsm.read() == ALLOC_UPT_CONFIG )
     1770      case CONFIG_DIR_IVT_LOCK:  // enter this state in case of INVAL command
     1771                                 // Try to get both DIR & IVT locks, and return
     1772                                 // to LOOP state if IVT full.
     1773                                 // Register inval in IVT, and invalidate the
     1774                                 // directory if IVT not full.
     1775      {
     1776          if ( r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG )
    17611777          {
    17621778              size_t set        = m_y[(addr_t)(r_config_address.read())];
    … …  
    17721788#if DEBUG_MEMC_CONFIG
    17731789if(m_debug)
    1774 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
     1790std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
    17751791          << " No copies in L1 : inval DIR entry"  << std::endl;
    17761792#endif
    17771793              }
    1778               else    // try to register inval in UPT
     1794              else    // try to register inval in IVT
    17791795              {
    17801796                  bool        wok       = false;
    … …  
    17871803                  size_t      nb_copies = r_config_dir_count.read();
    17881804
    1789                   wok = m_upt.set(false,       // it's an inval transaction
     1805                  wok = m_ivt.set(false,       // it's an inval transaction
    17901806                                  broadcast,   
    17911807                                  false,       // no response required
    … …  
    17981814                                  index);
    17991815
    1800                   if ( wok )  // UPT success => inval DIR slot
     1816                  if ( wok )  // IVT success => inval DIR slot
    18011817                  {
    18021818                      m_cache_directory.inval( way, set );
    1803                       r_config_upt_index = index;
     1819                      r_config_ivt_index = index;
    18041820                      if ( broadcast )  r_config_fsm = CONFIG_BC_SEND;
    18051821                      else              r_config_fsm = CONFIG_INV_SEND;
    … …  
    18071823#if DEBUG_MEMC_CONFIG
    18081824if(m_debug)
    1809 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1810           << " Inval DIR entry and register inval in UPT"
     1825std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1826          << " Inval DIR entry and register inval in IVT"
    18111827          << " : index = " << std::dec << index
    18121828          << " / broadcast = " << broadcast << std::endl;
    18131829#endif
    18141830                  }
    1815                   else       // UPT full => release both DIR and UPT locks
     1831                  else       // IVT full => release both DIR and IVT locks
    18161832                  {
    18171833                      r_config_fsm = CONFIG_LOOP;
    … …  
    18191835#if DEBUG_MEMC_CONFIG
    18201836if(m_debug)
    1821 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1822           << " UPT full : release DIR & UPT locks and retry" << std::endl;
     1837std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1838          << " IVT full : release DIR & IVT locks and retry" << std::endl;
    18231839#endif
    18241840                  }
    … …  
    18351851              r_config_to_cc_send_multi_req   = false;
    18361852              r_config_to_cc_send_brdcast_req = true;
    1837               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1853              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    18381854              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    18391855              r_cleanup_to_config_ack         = false;
    … …  
    18751891              r_config_to_cc_send_multi_req   = true;
    18761892              r_config_to_cc_send_brdcast_req = false;
    1877               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1893              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    18781894              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    18791895              r_multi_ack_to_config_ack       = false;
    … …  
    20372053  switch(r_read_fsm.read())
    20382054  {
    2039       ///////////////
    2040       case READ_IDLE:  // waiting a read request
    2041       {
     2055    ///////////////
     2056    case READ_IDLE:  // waiting a read request
     2057    {
    20422058      if(m_cmd_read_addr_fifo.rok())
    20432059      {
    20442060
    20452061#if DEBUG_MEMC_READ
    2046 if(m_debug)
    2047 std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
    2048           << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
    2049           << " / srcid = " << m_cmd_read_srcid_fifo.read()
    2050           << " / trdid = " << m_cmd_read_trdid_fifo.read()
    2051           << " / pktid = " << m_cmd_read_pktid_fifo.read()
    2052           << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
     2062        if(m_debug)
     2063          std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
     2064            << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
     2065            << " / srcid = " << m_cmd_read_srcid_fifo.read()
     2066            << " / trdid = " << m_cmd_read_trdid_fifo.read()
     2067            << " / pktid = " << m_cmd_read_pktid_fifo.read()
     2068            << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
    20532069#endif
    20542070        r_read_fsm = READ_DIR_REQ;
    … …  
    21542170
    21552171    {
    2156         if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    2157         {
    2158             // check if this is an instruction read, this means pktid is either
    2159             // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
    2160             // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    2161             bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    2162             // check if this is a cached read, this means pktid is either
    2163             // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
    2164             // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    2165             bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
    2166             bool is_cnt       = r_read_is_cnt.read();
    2167 
    2168             // read data in the cache
    2169             size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    2170             size_t way        = r_read_way.read();
    2171 
    2172             m_cache_data.read_line(way, set, r_read_data);
    2173 
    2174             if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
     2172      if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     2173      {
     2174        // check if this is an instruction read, this means pktid is either
     2175        // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
     2176        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     2177        bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
     2178        // check if this is a cached read, this means pktid is either
     2179        // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
     2180        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     2181        bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
     2182        bool is_cnt       = r_read_is_cnt.read();
     2183
     2184        // read data in the cache
     2185        size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
     2186        size_t way        = r_read_way.read();
     2187
     2188        m_cache_data.read_line(way, set, r_read_data);
     2189
     2190        if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
    21752191
    21762192        // update the cache directory
    … …  
    22232239
    22242240#if DEBUG_MEMC_READ
    2225 if(m_debug)
    2226 std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    2227           << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
    2228           << " / set = " << std::dec << set
    2229           << " / way = " << way
    2230           << " / owner_id = " << std::hex << entry.owner.srcid
    2231           << " / owner_ins = " << std::dec << entry.owner.inst
    2232           << " / count = " << entry.count
    2233           << " / is_cnt = " << entry.is_cnt << std::endl;
     2241        if(m_debug)
     2242          std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
     2243            << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
     2244            << " / set = " << std::dec << set
     2245            << " / way = " << way
     2246            << " / owner_id = " << std::hex << entry.owner.srcid
     2247            << " / owner_ins = " << std::dec << entry.owner.inst
     2248            << " / count = " << entry.count
     2249            << " / is_cnt = " << entry.is_cnt << std::endl;
    22342250#endif
    22352251
    … …  
    29772993
    29782994        wok = m_upt.set(true,  // it's an update transaction
    2979                         false,    // it's not a broadcast
    2980                         true,     // response required
    2981                         false,    // no acknowledge required
     2995                        false, // it's not a broadcast
     2996                        true,  // response required
     2997                        false, // no acknowledge required
    29822998                        srcid,   
    29832999                        trdid,
    … …  
    31393155          entry.owner.inst)             // put the next srcid in the fifo
    31403156      {
    3141         dec_upt_counter                 = false;
     3157        dec_upt_counter                = false;
    31423158        write_to_cc_send_fifo_put      = true;
    31433159        write_to_cc_send_fifo_inst     = entry.owner.inst;
    … …  
    31923208      {
    31933209        r_write_to_cc_send_multi_req = true;
    3194         if(r_write_to_dec.read() or dec_upt_counter)   r_write_fsm = WRITE_UPT_DEC;
     3210        if(r_write_to_dec.read() or dec_upt_counter)  r_write_fsm = WRITE_UPT_DEC;
    31953211        else                                          r_write_fsm = WRITE_IDLE;
    31963212      }
    … …  
    34443460        {
    34453461          r_write_trt_index = wok_index;
    3446           r_write_fsm       = WRITE_BC_UPT_LOCK;
     3462          r_write_fsm       = WRITE_BC_IVT_LOCK;
    34473463        }
    34483464        else  // wait an empty entry in TRT
    … …  
    34653481
    34663482    //////////////////////
    3467     case WRITE_BC_UPT_LOCK:      // register BC transaction in UPT
    3468     {
    3469       if(r_alloc_upt_fsm.read() == ALLOC_UPT_WRITE)
     3483    case WRITE_BC_IVT_LOCK:      // register BC transaction in IVT
     3484    {
     3485      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    34703486      {
    34713487        bool        wok       = false;
    … …  
    34773493        size_t      nb_copies = r_write_count.read();
    34783494
    3479         wok = m_upt.set(false,  // it's an inval transaction
    3480                         true,     // it's a broadcast
    3481                         true,     // response required
    3482                         false,    // no acknowledge required
     3495        wok = m_ivt.set(false,  // it's an inval transaction
     3496                        true,   // it's a broadcast
     3497                        true,   // response required
     3498                        false,  // no acknowledge required
    34833499                        srcid,
    34843500                        trdid,
    … …  
    34893505#if DEBUG_MEMC_WRITE
    34903506if( m_debug and wok )
    3491 std::cout << "  <MEMC " << name() << " WRITE_BC_UPT_LOCK> Register broadcast inval in UPT"
     3507std::cout << "  <MEMC " << name() << " WRITE_BC_IVT_LOCK> Register broadcast inval in IVT"
    34923508          << " / nb_copies = " << r_write_count.read() << std::endl;
    34933509#endif
    … …  
    34953511
    34963512        if(wok) r_write_fsm = WRITE_BC_DIR_INVAL;
    3497         else       r_write_fsm = WRITE_WAIT;
     3513        else    r_write_fsm = WRITE_WAIT;
    34983514        m_cpt_write_fsm_n_upt_lock++;
    34993515      }
    … …  
    35103526      // and invalidate the line in directory
    35113527      if((r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE) or
    3512           (r_alloc_upt_fsm.read() != ALLOC_UPT_WRITE) or
    3513           (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
     3528         (r_alloc_ivt_fsm.read() != ALLOC_IVT_WRITE) or
     3529         (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
    35143530      {
    35153531        std::cout << "VCI_MEM_CACHE ERROR " << name() << " WRITE_BC_DIR_INVAL state" << std::endl;
    3516         std::cout << "bad TRT, DIR, or UPT allocation" << std::endl;
     3532        std::cout << "bad TRT, DIR, or IVT allocation" << std::endl;
    35173533        exit(0);
    35183534      }
    … …  
    36363652      else if(r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
    36373653      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3654#if ODCCP_NON_INCLUSIVE
    36383655      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3656#else
     3657      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_TRT_LOCK;
     3658#endif
    36393659      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    36403660      break;
    … …  
    36433663      if(r_cas_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CAS;
    36443664      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3665#if ODCCP_NON_INCLUSIVE
    36453666      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3667#else
     3668      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_TRT_LOCK;
     3669#endif
    36463670      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    36473671      else if(r_write_to_ixr_cmd_req)    r_ixr_cmd_fsm = IXR_CMD_WRITE;
    … …  
    36503674    case IXR_CMD_CAS_IDLE:
    36513675      if(r_xram_rsp_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3676#if ODCCP_NON_INCLUSIVE
    36523677      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3678#else
     3679      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_TRT_LOCK;
     3680#endif
    36533681      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    36543682      else if(r_write_to_ixr_cmd_req)    r_ixr_cmd_fsm = IXR_CMD_WRITE;
    … …  
    36573685    ////////////////////////
    36583686    case IXR_CMD_XRAM_IDLE:
     3687#if ODCCP_NON_INCLUSIVE
    36593688      if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3689#else
     3690      if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_TRT_LOCK;
     3691#endif
    36603692      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    36613693      else if(r_write_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_WRITE;
    … …  
    36693701      else if(r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
    36703702      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3703#if ODCCP_NON_INCLUSIVE
    36713704      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
    3672       break;     
     3705#else
     3706      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_TRT_LOCK;
     3707#endif
     3708      break;     
     3709
     3710    /////////////////////
     3711    case IXR_CMD_TRT_LOCK:
     3712    {
     3713        TransactionTabEntry entry;
     3714       
     3715        if(r_alloc_trt_fsm.read() != ALLOC_TRT_IXR_CMD) break;
     3716        entry.copy( m_trt.read(r_cleanup_to_ixr_cmd_trdid.read()));
     3717        for(size_t i=0; i < m_words; i++)
     3718        {
     3719          r_ixr_cmd_data[i] = entry.wdata[i];
     3720        }
     3721
     3722        r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3723        break;
     3724    }
     3725
    36733726    //////////////////       // send a get from READ FSM
    36743727    case IXR_CMD_READ:
    … …  
    38063859          r_ixr_cmd_fsm = IXR_CMD_CLEANUP_IDLE;
    38073860          r_cleanup_to_ixr_cmd_req = false;
    3808           r_xram_rsp_to_ixr_cmd_inval_ncc_pending = false;
     3861          //r_xram_rsp_to_ixr_cmd_inval_ncc_pending = false;
    38093862        }
    38103863        else
    … …  
    39904043      size_t ptr   = r_xram_rsp_trt_index.read();
    39914044      size_t lines = m_trt_lines;
     4045     
    39924046      for(size_t i=0 ; i<lines ; i++)
    39934047      {
    … …  
    40814135#else
    40824136          /*ODCCP*/ //if victim is no coherent and there is an inval no coherent pending we wait
    4083           if(!victim.coherent and r_xram_rsp_to_ixr_cmd_inval_ncc_pending.read())
     4137          /*if(!victim.coherent and r_xram_rsp_to_ixr_cmd_inval_ncc_pending.read())
    40844138          {
    40854139            r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    40864140          }
    40874141          else
    4088           {
     4142          {*/
    40894143            r_xram_rsp_fsm = XRAM_RSP_INVAL_LOCK;
    4090           }
     4144         //}
    40914145#endif
    40924146        }
    … …  
    41024156          << " way = " << std::dec << way
    41034157          << " / set = " << set
     4158          << " / victim coherent = " << victim.coherent
     4159          << " / victim owner id = " << victim.owner.srcid
    41044160          << " / inval_required = " << inval << std::endl;
    41054161#endif
    … …  
    41144170    }
    41154171    /////////////////////////
    4116     case XRAM_RSP_INVAL_LOCK: // Take the UPT lock to check a possible pending inval
    4117     {
    4118       if(r_alloc_upt_fsm == ALLOC_UPT_XRAM_RSP)
     4172    case XRAM_RSP_INVAL_LOCK: // Take the IVT lock to check a possible pending inval
     4173    {
     4174      if(r_alloc_ivt_fsm == ALLOC_IVT_XRAM_RSP)
    41194175      {
    41204176        size_t index = 0;
    4121         if(m_upt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
     4177        if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
    41224178        {
    41234179          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    … …  
    41264182if(m_debug)
    41274183std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    4128           << " Get acces to UPT, but line invalidation registered"
     4184          << " Get acces to IVT, but line invalidation registered"
    41294185          << " / nline = " << std::hex << r_xram_rsp_trt_buf.nline
    41304186          << " / index = " << std::dec << index << std::endl;
    … …  
    41324188
    41334189        }
    4134         else if(m_upt.is_full() and r_xram_rsp_victim_inval.read()) // UPT full
     4190        else if(m_ivt.is_full() and r_xram_rsp_victim_inval.read()) // IVT full
    41354191        {
    41364192          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    … …  
    41394195if(m_debug)
    41404196std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    4141           << " Get acces to UPT, but inval required and UPT full" << std::endl;
     4197          << " Get acces to IVT, but inval required and IVT full" << std::endl;
    41424198#endif
    41434199        }
    … …  
    41494205if(m_debug)
    41504206std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    4151           << " Get acces to UPT" << std::endl;
     4207          << " Get acces to IVT" << std::endl;
    41524208#endif
    41534209        }
    … …  
    41734229    ///////////////////////
    41744230    case XRAM_RSP_DIR_UPDT:   // updates the cache (both data & directory)
    4175                               // and possibly set an inval request in UPT
     4231                              // and possibly set an inval request in IVT
    41764232    {
    41774233      // check if this is an instruction read, this means pktid is either
    … …  
    42414297      m_cache_directory.write(set, way, entry);
    42424298
    4243       // request an invalidation request in UPT for victim line
     4299      // request an invalidation request in IVT for victim line
    42444300      if(r_xram_rsp_victim_inval.read())
    42454301      {
    … …  
    42474303        size_t index        = 0;
    42484304        size_t count_copies = r_xram_rsp_victim_count.read();
    4249 
    4250         bool   wok = m_upt.set(false,      // it's an inval transaction
     4305       
     4306        bool   wok = m_ivt.set(false,      // it's an inval transaction
    42514307                               broadcast,  // set broadcast bit
    42524308                               false,      // no response required
    … …  
    42594315                               index);
    42604316
    4261         r_xram_rsp_upt_index = index;
     4317        r_xram_rsp_ivt_index = index;
    42624318
    42634319        if(!wok)
    42644320        {
    42654321          std::cout << "VCI_MEM_CACHE ERROR " << name() << " XRAM_RSP_DIR_UPDT"
    4266                     << " update_tab entry free but write unsuccessful" << std::endl;
     4322                    << " invalidate_tab entry free but write unsuccessful" << std::endl;
    42674323          exit(0);
    42684324        }
    … …  
    43134369      if(r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP)
    43144370      {
    4315         m_trt.set(r_xram_rsp_trt_index.read(),
     4371        std::vector<data_t> data_vector;
     4372        data_vector.clear();
     4373       
     4374        for(size_t i=0; i<m_words; i++)
     4375        {
     4376          data_vector.push_back(r_xram_rsp_victim_data[i]);
     4377        }
     4378        /*m_trt.set(r_xram_rsp_trt_index.read(),
    43164379                              false,       // write to XRAM
    43174380                              r_xram_rsp_victim_nline.read(),  // line index
    … …  
    43234386                              0,
    43244387                              std::vector<be_t> (m_words,0),
    4325                               std::vector<data_t> (m_words,0));
     4388                              std::vector<data_t> (m_words,0));*/
     4389       
     4390        m_trt.set(r_xram_rsp_trt_index.read(),
     4391                  false,       // write to XRAM
     4392                  r_xram_rsp_victim_nline.read(),  // line index
     4393                  0,
     4394                  0,
     4395                  0,
     4396                  false,
     4397                  0,
     4398                  0,
     4399                  std::vector<be_t> (m_words,0),
     4400                  data_vector);
    43264401
    43274402#if DEBUG_MEMC_XRAM_RSP
    … …  
    43954470        r_xram_rsp_to_cc_send_brdcast_req  = r_xram_rsp_victim_is_cnt.read();
    43964471        r_xram_rsp_to_cc_send_nline        = r_xram_rsp_victim_nline.read();
    4397         r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_upt_index;
     4472        r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_ivt_index;
    43984473        xram_rsp_to_cc_send_fifo_srcid     = r_xram_rsp_victim_copy.read();
    43994474        xram_rsp_to_cc_send_fifo_inst      = r_xram_rsp_victim_copy_inst.read();
    … …  
    44274502    case XRAM_RSP_WRITE_DIRTY:  // send a write request to IXR_CMD FSM
    44284503    {
    4429       if((!r_xram_rsp_to_ixr_cmd_req.read()) and (!r_xram_rsp_to_ixr_cmd_inval_ncc_pending.read()))
     4504      if((!r_xram_rsp_to_ixr_cmd_req.read()) /*and (!r_xram_rsp_to_ixr_cmd_inval_ncc_pending.read())*/)
    44304505      {
    44314506
    … …  
    44434518        if( (!r_xram_rsp_victim_coherent.read()) and (r_xram_rsp_victim_count.read() == 1) )
    44444519        {
    4445           r_xram_rsp_to_ixr_cmd_inval_ncc_pending = true; // inval no coherent pending
     4520          //r_xram_rsp_to_ixr_cmd_inval_ncc_pending = true; // inval no coherent pending
    44464521          r_xram_rsp_to_ixr_cmd_req = false;
    44474522          r_xram_rsp_fsm = XRAM_RSP_IDLE;
    … …  
    46334708        DspinDhccpParam::dspin_get(
    46344709            flit,
    4635             DspinDhccpParam::FROM_L1_TYPE);
     4710            DspinDhccpParam::P2M_TYPE);
    46364711
    46374712      r_cleanup_way_index =
    … …  
    46894764        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB);
    46904765     
    4691       bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::FROM_L1_EOP);
     4766      bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP);
    46924767     
    46934768      /*ODCCP*/ // if not eop (more than 2 flits) there is a cleanup no coherent with data
    … …  
    47114786std::cout << "  <MEMC "         << name()
    47124787          << " CLEANUP_GET_NLINE> Cleanup request:"
     4788          << " / ncc = "     << r_cleanup_ncc.read()
    47134789          << " / address = " << std::hex << nline * m_words * 4 << std::endl;
    47144790#endif
    … …  
    48194895      else                // miss : check UPT for a pending invalidation transaction
    48204896      {
    4821         r_cleanup_fsm = CLEANUP_UPT_LOCK;
     4897        r_cleanup_fsm = CLEANUP_IVT_LOCK;
    48224898      }
    48234899
    … …  
    52895365    }
    52905366    //////////////////////
    5291     case CLEANUP_UPT_LOCK:   // get the lock protecting the UPT to search a pending
     5367    case CLEANUP_IVT_LOCK:   // get the lock protecting the IVT to search a pending
    52925368                             // invalidate transaction matching the cleanup
    52935369    {
    52945370      m_cpt_cleanup_fsm_upt_lock++;
    5295       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP) break;
     5371      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    52965372
    52975373      size_t index = 0;
    52985374      bool   match_inval;
    52995375
    5300       match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
     5376      match_inval = m_ivt.search_inval(r_cleanup_nline.read(), index);
    53015377
    53025378      if ( not match_inval )     // no pending inval
    … …  
    53155391if(m_debug)
    53165392std::cout << "  <MEMC " << name()
    5317           << " CLEANUP_UPT_LOCK> Unexpected cleanup"
    5318           << " with no corresponding UPT entry:"
     5393          << " CLEANUP_IVT_LOCK> Unexpected cleanup"
     5394          << " with no corresponding IVT entry:"
    53195395          << " address = " << std::hex
    53205396          << (r_cleanup_nline.read() *4*m_words)
    … …  
    53265402
    53275403      // pending inval
    5328       r_cleanup_write_srcid = m_upt.srcid(index);
    5329       r_cleanup_write_trdid = m_upt.trdid(index);
    5330       r_cleanup_write_pktid = m_upt.pktid(index);
    5331       r_cleanup_need_rsp    = m_upt.need_rsp(index);
    5332       r_cleanup_need_ack    = m_upt.need_ack(index);
     5404      r_cleanup_write_srcid = m_ivt.srcid(index);
     5405      r_cleanup_write_trdid = m_ivt.trdid(index);
     5406      r_cleanup_write_pktid = m_ivt.pktid(index);
     5407      r_cleanup_need_rsp    = m_ivt.need_rsp(index);
     5408      r_cleanup_need_ack    = m_ivt.need_ack(index);
    53335409      r_cleanup_index       = index;
    53345410
    5335       r_cleanup_fsm         = CLEANUP_UPT_DECREMENT;
     5411      r_cleanup_fsm         = CLEANUP_IVT_DECREMENT;
    53365412
    53375413#if DEBUG_MEMC_CLEANUP
    53385414if(m_debug)
    53395415std::cout << "  <MEMC " << name()
    5340           << " CLEANUP_UPT_LOCK> Cleanup matching pending"
    5341           << " invalidate transaction on UPT:"
     5416          << " CLEANUP_IVT_LOCK> Cleanup matching pending"
     5417          << " invalidate transaction on IVT:"
    53425418          << " address = " << std::hex << r_cleanup_nline.read() * m_words * 4
    5343           << " / upt_entry = " << index << std::endl;
     5419          << " / ivt_entry = " << index << std::endl;
    53445420#endif
    53455421      break;
    53465422    }
    53475423    ///////////////////////////
    5348     case CLEANUP_UPT_DECREMENT:   // decrement response counter in UPT matching entry
    5349     {
    5350       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     5424    case CLEANUP_IVT_DECREMENT: // decrement response counter in IVT matching entry
     5425    {
     5426      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    53515427      {
    53525428        std::cout
    53535429            << "VCI_MEM_CACHE ERROR "         << name()
    5354             << " CLEANUP_UPT_DECREMENT state" << std::endl
    5355             << "Bad UPT allocation"
     5430            << " CLEANUP_IVT_DECREMENT state" << std::endl
     5431            << "Bad IVT allocation"
    53565432            << std::endl;
    53575433
    … …  
    53605436
    53615437      size_t count = 0;
    5362       m_upt.decrement(r_cleanup_index.read(), count);
     5438      m_ivt.decrement(r_cleanup_index.read(), count);
    53635439
    53645440      if(count == 0)   // multi inval transaction completed
    53655441      {
    5366         r_cleanup_fsm = CLEANUP_UPT_CLEAR;
     5442        r_cleanup_fsm = CLEANUP_IVT_CLEAR;
    53675443      }
    53685444      else             // multi inval transaction not completed
    … …  
    53815457#if DEBUG_MEMC_CLEANUP
    53825458if(m_debug)
    5383 std::cout << "  <MEMC " << name() << " CLEANUP_UPT_DECREMENT>"
    5384           << " Decrement response counter in UPT:"
    5385             << " UPT_index = " << r_cleanup_index.read()
     5459std::cout << "  <MEMC " << name() << " CLEANUP_IVT_DECREMENT>"
     5460          << " Decrement response counter in IVT:"
     5461            << " IVT_index = " << r_cleanup_index.read()
    53865462            << " / rsp_count = " << count << std::endl;
    53875463#endif
    … …  
    53895465    }
    53905466    ///////////////////////
    5391     case CLEANUP_UPT_CLEAR:    // Clear UPT entry
    5392     {
    5393       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     5467    case CLEANUP_IVT_CLEAR:    // Clear IVT entry
     5468    {
     5469      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    53945470      {
    53955471        std::cout
    53965472            << "VCI_MEM_CACHE ERROR "     << name()
    5397             << " CLEANUP_UPT_CLEAR state" << std::endl
    5398             << "Bad UPT allocation"
     5473            << " CLEANUP_IVT_CLEAR state" << std::endl
     5474            << "Bad IVT allocation"
    53995475            << std::endl;
    54005476
    … …  
    54025478      }
    54035479
    5404       m_upt.clear(r_cleanup_index.read());
     5480      m_ivt.clear(r_cleanup_index.read());
    54055481
    54065482      if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
    … …  
    54125488if(m_debug)
    54135489std::cout << "  <MEMC "      << name()
    5414           << " CLEANUP_UPT_CLEAR> Clear entry in UPT:"
    5415           << " UPT_index = " << r_cleanup_index.read() << std::endl;
     5490          << " CLEANUP_IVT_CLEAR> Clear entry in IVT:"
     5491          << " IVT_index = " << r_cleanup_index.read() << std::endl;
    54165492#endif
    54175493      break;
    … …  
    54875563            r_cleanup_to_ixr_cmd_pktid        = r_cleanup_pktid.read();
    54885564            r_cleanup_to_ixr_cmd_nline        = r_cleanup_nline.read();
    5489             r_cleanup_to_ixr_cmd_l1_dirty_ncc = true;
     5565            //r_cleanup_to_ixr_cmd_l1_dirty_ncc = true;
    54905566            r_cleanup_fsm = CLEANUP_SEND_CLACK;
    54915567          }
    … …  
    55055581          r_cleanup_to_ixr_cmd_req     = true;
    55065582
    5507           for(size_t i = 0; i < m_words; i++){
    5508             r_cleanup_to_ixr_cmd_data[i]   = r_cleanup_data[i];
     5583          if (r_cleanup_contains_data.read())
     5584          { 
     5585            std::vector<data_t> data_vector;
     5586            data_vector.clear();
     5587
     5588            for(size_t i=0; i<m_words; i++)
     5589            {
     5590              data_vector.push_back(r_cleanup_data[i]);
     5591            }
     5592
     5593            m_trt.set(index,
     5594                false,       // write to XRAM
     5595                r_cleanup_nline.read(),  // line index
     5596                0,
     5597                0,
     5598                0,
     5599                false,
     5600                0,
     5601                0,
     5602                std::vector<be_t> (m_words,0),
     5603                data_vector);
    55095604          }
    5510 
    55115605          r_cleanup_to_ixr_cmd_srcid        = r_cleanup_srcid.read();
    55125606          r_cleanup_to_ixr_cmd_trdid        = index;
    55135607          r_cleanup_to_ixr_cmd_pktid        = r_cleanup_pktid.read();
    55145608          r_cleanup_to_ixr_cmd_nline        = r_cleanup_nline.read();
    5515           r_cleanup_to_ixr_cmd_l1_dirty_ncc = r_cleanup_contains_data.read();
     5609          //r_cleanup_to_ixr_cmd_l1_dirty_ncc = r_cleanup_contains_data.read();
    55165610          r_cleanup_fsm = CLEANUP_SEND_CLACK;
    55175611#endif
    … …  
    55475641
    55485642    ////////////////////////
    5549     case CLEANUP_SEND_CLACK:    // acknowledgement to a cleanup command
    5550                               // on the coherence network (request to the CC_SEND FSM).
    5551                               // wait if pending request to the CC_SEND FSM
    5552     {
    5553       if(r_cleanup_to_cc_send_req.read()) break;
    5554 
    5555       r_cleanup_to_cc_send_req       = true;
    5556       r_cleanup_to_cc_send_set_index = r_cleanup_nline.read() & 0xFFFF;
    5557       r_cleanup_to_cc_send_way_index = r_cleanup_way_index.read();
    5558       r_cleanup_to_cc_send_srcid     = r_cleanup_srcid.read();
    5559       r_cleanup_to_cc_send_inst      = r_cleanup_inst.read();
     5643    case CLEANUP_SEND_CLACK:  // acknowledgement to a cleanup command
     5644                              // on the coherence CLACK network.
     5645    {
     5646      if(not p_dspin_clack.read) break;
    55605647
    55615648      r_cleanup_fsm = CLEANUP_IDLE;
    … …  
    55655652std::cout << "  <MEMC " << name()
    55665653          << " CLEANUP_SEND_CLACK> Send the response to a cleanup request:"
    5567           << " srcid = " << std::dec << r_cleanup_srcid.read() << std::endl;
     5654          << " nline = "   << std::hex << r_cleanup_nline.read()
     5655          << " / way = "   << std::dec << r_cleanup_way.read()
     5656          << " / srcid = " << std::dec << r_cleanup_srcid.read()
     5657          << std::endl;
    55685658#endif
    55695659      break;
    … …  
    58045894                !r_cas_to_cc_send_brdcast_req.read())
    58055895        {
    5806           r_cas_fsm = CAS_UPT_LOCK;     // multi update required
     5896          r_cas_fsm = CAS_UPT_LOCK;       // multi update required
    58075897        }
    58085898        else
    … …  
    60776167          {
    60786168            r_cas_trt_index = wok_index;
    6079             r_cas_fsm       = CAS_BC_UPT_LOCK;
     6169            r_cas_fsm       = CAS_BC_IVT_LOCK;
    60806170          }
    60816171          else
    … …  
    60966186    }
    60976187    /////////////////////
    6098     case CAS_BC_UPT_LOCK:  // register a broadcast inval transaction in UPT
     6188    case CAS_BC_IVT_LOCK:  // register a broadcast inval transaction in IVT
    60996189                           // write data in cache in case of successful registration
    61006190    {
    6101       if(r_alloc_upt_fsm.read() == ALLOC_UPT_CAS)
     6191      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS)
    61026192      {
    61036193        bool        wok       = false;
    … …  
    61096199        size_t      nb_copies = r_cas_count.read();
    61106200
    6111         // register a broadcast inval transaction in UPT
    6112         wok = m_upt.set(false,  // it's an inval transaction
    6113                         true,    // it's a broadcast
    6114                         true,    // response required
    6115                         false,   // no acknowledge required
     6201        // register a broadcast inval transaction in IVT
     6202        wok = m_ivt.set(false,  // it's an inval transaction
     6203                        true,   // it's a broadcast
     6204                        true,   // response required
     6205                        false,  // no acknowledge required
    61166206                        srcid,
    61176207                        trdid,
    … …  
    61216211                        index);
    61226212
    6123         if(wok)     // UPT not full
     6213        if(wok)     // IVT not full
    61246214        {
    61256215          // cache update
    … …  
    61476237if(m_debug)
    61486238std::cout << "  <MEMC " << name()
    6149           << " CAS_BC_UPT_LOCK> Register a broadcast inval transaction in UPT"
     6239          << " CAS_BC_IVT_LOCK> Register a broadcast inval transaction in IVT"
    61506240          << " / nline = " << std::hex << nline
    61516241          << " / count = " << std::dec << nb_copies
    6152           << " / upt_index = " << index << std::endl;
    6153 #endif
    6154         }
    6155         else      //  releases the lock protecting UPT
     6242          << " / ivt_index = " << index << std::endl;
     6243#endif
     6244        }
     6245        else      //  releases the lock protecting IVT
    61566246        {
    61576247          r_cas_fsm = CAS_WAIT;
    … …  
    61686258    {
    61696259      if((r_alloc_trt_fsm.read() == ALLOC_TRT_CAS) and
    6170           (r_alloc_upt_fsm.read() == ALLOC_UPT_CAS) and
    6171           (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
     6260         (r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS) and
     6261         (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
    61726262      {
    61736263        // set TRT
    … …  
    64166506  // network, used to update or invalidate cache lines in L1 caches.
    64176507  //
    6418   // This fsm is used also to acknowledge CLEANUP a command after request from
    6419   // the CLEANUP fsm.
    6420   //
    6421   // It implements a round-robin priority between the five possible client FSMs
    6422   //     XRAM_RSP > CAS > CLEANUP > WRITE > CONFIG
     6508  // It implements a round-robin priority between the four possible client FSMs
     6509  //     XRAM_RSP > CAS > WRITE > CONFIG
    64236510  //
    64246511  // Each FSM can request the next services:
    … …  
    64326519  //   r_config_to_cc_send_brdcast_req : broadcast-inval
    64336520  //   
    6434   // - r_cleanup_to_cc_send_req : cleanup acknowledgement
    6435   //
    64366521  // An inval request is a double DSPIN flit command containing:
    64376522  // 1. the index of the line to be invalidated.
    … …  
    64766561          break;
    64776562        }
    6478         // CLEANUP
    6479         if (r_cleanup_to_cc_send_req.read())
    6480         {
    6481           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6482           break;
    6483         }
    64846563        // WRITE
    64856564        if(m_write_to_cc_send_inst_fifo.rok() or
    … …  
    65556634          break;
    65566635        }
    6557         // CLEANUP
    6558         if (r_cleanup_to_cc_send_req.read())
    6559         {
    6560           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6561           break;
    6562         }
    65636636        // WRITE
    65646637        if(m_write_to_cc_send_inst_fifo.rok() or
    … …  
    65946667          break;
    65956668        }
    6596         // CLEANUP
    6597         if(r_cleanup_to_cc_send_req.read())
    6598         {
    6599           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6600           break;
    6601         }
    66026669        // WRITE
    66036670        if(m_write_to_cc_send_inst_fifo.rok() or
    … …  
    66476714      case CC_SEND_CAS_IDLE:   // CLEANUP FSM has highest priority
    66486715      {
    6649         if(r_cleanup_to_cc_send_req.read())
    6650         {
    6651           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6652           break;
    6653         }
    66546716        if(m_write_to_cc_send_inst_fifo.rok() or
    66556717            r_write_to_cc_send_multi_req.read())
    … …  
    67066768        break;
    67076769      }
    6708       //////////////////////////
    6709       case CC_SEND_CLEANUP_IDLE:   // WRITE FSM has highest priority
    6710       {
    6711         // WRITE
    6712         if(m_write_to_cc_send_inst_fifo.rok() or
    6713             r_write_to_cc_send_multi_req.read())
    6714         {
    6715           r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6716           m_cpt_update++;
    6717           break;
    6718         }
    6719         if(r_write_to_cc_send_brdcast_req.read())
    6720         {
    6721           r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6722           m_cpt_inval++;
    6723           break;
    6724         }
    6725         // CONFIG
    6726         if(r_config_to_cc_send_multi_req.read())
    6727         {
    6728           r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6729           m_cpt_inval++;
    6730           break;
    6731         }
    6732         if(r_config_to_cc_send_brdcast_req.read())
    6733         {
    6734           r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6735           m_cpt_inval++;
    6736           break;
    6737         }
    6738         // XRAM_RSP
    6739         if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    6740             r_xram_rsp_to_cc_send_multi_req.read())
    6741         {
    6742           r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6743           m_cpt_inval++;
    6744           break;
    6745         }
    6746         if(r_xram_rsp_to_cc_send_brdcast_req.read())
    6747         {
    6748           r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6749           m_cpt_inval++;
    6750           break;
    6751         }
    6752         // CAS
    6753         if(m_cas_to_cc_send_inst_fifo.rok() or
    6754             r_cas_to_cc_send_multi_req.read())
    6755         {
    6756           r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6757           m_cpt_update++;
    6758           break;
    6759         }
    6760         if(r_cas_to_cc_send_brdcast_req.read())
    6761         {
    6762           r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6763           m_cpt_inval++;
    6764           break;
    6765         }
    6766         // CLEANUP
    6767         if(r_cleanup_to_cc_send_req.read())
    6768         {
    6769           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6770           break;
    6771         }
    6772         break;
    6773       }
    67746770      /////////////////////////////////
    67756771      case CC_SEND_CONFIG_INVAL_HEADER:   // send first flit multi-inval (from CONFIG FSM)
    … …  
    67776773        if(m_config_to_cc_send_inst_fifo.rok())
    67786774        {
    6779           if(not p_dspin_out.read) break;
     6775          if(not p_dspin_m2p.read) break;
    67806776          r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    67816777          break;
    … …  
    67886784      case CC_SEND_CONFIG_INVAL_NLINE:    // send second flit multi-inval (from CONFIG FSM)
    67896785      {
    6790         if(not p_dspin_out.read) break;
     6786        if(not p_dspin_m2p.read) break;
    67916787        m_cpt_inval_mult++;
    67926788        config_to_cc_send_fifo_get = true;
    … …  
    68046800      case CC_SEND_CONFIG_BRDCAST_HEADER:   // send first flit BC-inval (from CONFIG FSM)
    68056801      {
    6806         if(not p_dspin_out.read) break;
     6802        if(not p_dspin_m2p.read) break;
    68076803        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_NLINE;
    68086804        break;
    … …  
    68116807      case CC_SEND_CONFIG_BRDCAST_NLINE:    // send second flit BC-inval (from CONFIG FSM)
    68126808      {
    6813         if(not p_dspin_out.read) break;
     6809        if(not p_dspin_m2p.read) break;
    68146810        m_cpt_inval_brdcast++;
    68156811        r_config_to_cc_send_brdcast_req = false;
    … …  
    68246820        break;
    68256821      }
    6826       /////////////////////////
    6827       case CC_SEND_CLEANUP_ACK:   // send one flit for a cleanup acknowledgement
    6828       {
    6829         if(not p_dspin_out.read) break;
    6830 
    6831         r_cleanup_to_cc_send_req = false;
    6832         r_cc_send_fsm = CC_SEND_CLEANUP_IDLE;
    6833 
    6834 #if DEBUG_MEMC_CC_SEND
    6835 if(m_debug)
    6836 std::cout << "  <MEMC " << name()
    6837           << " CC_SEND_CLEANUP_ACK> Cleanup Ack for srcid "
    6838           << std::hex << r_cleanup_to_cc_send_srcid.read() << std::endl;
    6839 #endif
    6840         break;
    6841       }
    68426822      ///////////////////////////////////
    68436823      case CC_SEND_XRAM_RSP_INVAL_HEADER:   // send first flit multi-inval (from XRAM_RSP FSM)
    … …  
    68456825        if(m_xram_rsp_to_cc_send_inst_fifo.rok())
    68466826        {
    6847           if(not p_dspin_out.read) break;
     6827          if(not p_dspin_m2p.read) break;
    68486828          r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    68496829          break;
    … …  
    68566836      case CC_SEND_XRAM_RSP_INVAL_NLINE:   // send second flit multi-inval (from XRAM_RSP FSM)
    68576837      {
    6858         if(not p_dspin_out.read) break;
     6838        if(not p_dspin_m2p.read) break;
    68596839        m_cpt_inval_mult++;
    68606840        xram_rsp_to_cc_send_fifo_get = true;
    … …  
    68646844if(m_debug)
    68656845std::cout << "  <MEMC " << name()
    6866           << " CC_SEND_XRAM_RSP_INVAL_NLINE> BC-Inval for line "
     6846          << " CC_SEND_XRAM_RSP_INVAL_NLINE> Multicast-Inval for line "
    68676847          << std::hex << r_xram_rsp_to_cc_send_nline.read() << std::endl;
    68686848#endif
    … …  
    68726852      case CC_SEND_XRAM_RSP_BRDCAST_HEADER:  // send first flit broadcast-inval (from XRAM_RSP FSM)
    68736853      {
    6874         if(not p_dspin_out.read) break;
     6854        if(not p_dspin_m2p.read) break;
    68756855        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_NLINE;
    68766856        break;
    … …  
    68796859      case CC_SEND_XRAM_RSP_BRDCAST_NLINE:   // send second flit broadcast-inval (from XRAM_RSP FSM)
    68806860      {
    6881         if(not p_dspin_out.read) break;
     6861        if(not p_dspin_m2p.read) break;
    68826862        m_cpt_inval_brdcast++;
    68836863        r_xram_rsp_to_cc_send_brdcast_req = false;
    … …  
    68956875      case CC_SEND_WRITE_BRDCAST_HEADER:   // send first flit broadcast-inval (from WRITE FSM)
    68966876      {
    6897         if(not p_dspin_out.read) break;
     6877        if(not p_dspin_m2p.read) break;
    68986878        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_NLINE;
    68996879        break;
    … …  
    69026882      case CC_SEND_WRITE_BRDCAST_NLINE:   // send second flit broadcast-inval (from WRITE FSM)
    69036883      {
    6904         if(not p_dspin_out.read) break;
     6884        if(not p_dspin_m2p.read) break;
    69056885
    69066886        m_cpt_inval_brdcast++;
    … …  
    69226902        if(m_write_to_cc_send_inst_fifo.rok())
    69236903        {
    6924           if(not p_dspin_out.read) break;
     6904          if(not p_dspin_m2p.read) break;
    69256905
    69266906          r_cc_send_fsm = CC_SEND_WRITE_UPDT_NLINE;
    … …  
    69396919      case CC_SEND_WRITE_UPDT_NLINE:   // send second flit for a multi-update (from WRITE FSM)
    69406920      {
    6941         if(not p_dspin_out.read) break;
     6921        if(not p_dspin_m2p.read) break;
    69426922        m_cpt_update_mult++;
    69436923
    … …  
    69566936      case CC_SEND_WRITE_UPDT_DATA:   // send N data flits for a multi-update (from WRITE FSM)
    69576937      {
    6958         if(not p_dspin_out.read) break;
     6938        if(not p_dspin_m2p.read) break;
    69596939        if(r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1))
    69606940        {
    … …  
    69706950      case CC_SEND_CAS_BRDCAST_HEADER:   // send first flit  broadcast-inval (from CAS FSM)
    69716951      {
    6972         if(not p_dspin_out.read) break;
     6952        if(not p_dspin_m2p.read) break;
    69736953        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_NLINE;
    69746954        break;
    … …  
    69776957      case CC_SEND_CAS_BRDCAST_NLINE:   // send second flit broadcast-inval (from CAS FSM)
    69786958      {
    6979         if(not p_dspin_out.read) break;
     6959        if(not p_dspin_m2p.read) break;
    69806960        m_cpt_inval_brdcast++;
    69816961
    … …  
    69966976        if(m_cas_to_cc_send_inst_fifo.rok())
    69976977        {
    6998           if(not p_dspin_out.read) break;
     6978          if(not p_dspin_m2p.read) break;
    69996979
    70006980          r_cc_send_fsm = CC_SEND_CAS_UPDT_NLINE;
    … …  
    70146994      case CC_SEND_CAS_UPDT_NLINE:   // send second flit for a multi-update (from CAS FSM)
    70156995      {
    7016         if(not p_dspin_out.read) break;
     6996        if(not p_dspin_m2p.read) break;
    70176997
    70186998        m_cpt_update_mult++;
    … …  
    70327012      case CC_SEND_CAS_UPDT_DATA:   // send first data for a multi-update (from CAS FSM)
    70337013      {
    7034         if(not p_dspin_out.read) break;
     7014        if(not p_dspin_m2p.read) break;
    70357015
    70367016        if(r_cas_to_cc_send_is_long.read())
    … …  
    70477027      case CC_SEND_CAS_UPDT_DATA_HIGH:   // send second data for a multi-update (from CAS FSM)
    70487028      {
    7049         if(not p_dspin_out.read) break;
     7029        if(not p_dspin_m2p.read) break;
    70507030        cas_to_cc_send_fifo_get = true;
    70517031        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    … …  
    70677047    case CC_RECEIVE_IDLE:
    70687048      {
    7069         if(not p_dspin_in.write) break;
     7049        if(not p_dspin_p2m.write) break;
    70707050
    70717051        uint8_t type =
    70727052          DspinDhccpParam::dspin_get(
    7073               p_dspin_in.data.read(),
    7074               DspinDhccpParam::FROM_L1_TYPE);
     7053              p_dspin_p2m.data.read(),
     7054              DspinDhccpParam::P2M_TYPE);
    70757055
    70767056        if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
    … …  
    70987078        // write first CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    70997079
    7100         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     7080        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    71017081          break;
    71027082
    7103         assert(not p_dspin_in.eop.read() and
     7083        assert(not p_dspin_p2m.eop.read() and
    71047084            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    71057085            "CLEANUP command must have two flits");
    … …  
    71157095        // write second CLEANUP flit in CC_RECEIVE to CLEANUP fifo or more in case of cleanup data (ODCCP)
    71167096
    7117         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     7097        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    71187098          break;
    71197099
    7120         /*assert(p_dspin_in.eop.read() and
    7121             "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    7122             "CLEANUP command must have two flits");*/
    7123 
    71247100        cc_receive_to_cleanup_fifo_put = true;
    7125         if(p_dspin_in.eop.read())
     7101        if(p_dspin_p2m.eop.read())
    71267102          r_cc_receive_fsm               = CC_RECEIVE_IDLE;
    71277103
    … …  
    71357111
    71367112        // wait for a WOK in the CC_RECEIVE to MULTI_ACK fifo
    7137         if(not p_dspin_in.write or not m_cc_receive_to_multi_ack_fifo.wok())
     7113        if(not p_dspin_p2m.write or not m_cc_receive_to_multi_ack_fifo.wok())
    71387114          break;
    71397115
    7140         assert(p_dspin_in.eop.read() and
     7116        assert(p_dspin_p2m.eop.read() and
    71417117            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    71427118            "MULTI_ACK command must have one flit");
    … …  
    75487524  //    ALLOC_UPT FSM
    75497525  ////////////////////////////////////////////////////////////////////////////////////
    7550   // The ALLOC_UPT FSM allocates the access to the Update/Inval Table (UPT),
    7551   // with a round robin priority between six FSMs, with the following order:
    7552   //  CONFIG > MULTI_ACK > WRITE > XRAM_RSP > CLEANUP > CAS
    7553   // - The CONFIG FSM initiates an inval transaction and sets a new entry in UPT.
     7526  // The ALLOC_UPT FSM allocates the access to the Update Table (UPT),
     7527  // with a round robin priority between three FSMs, with the following order:
     7528  //  WRITE -> CAS -> MULTI_ACK
     7529  // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
     7530  // - The CAS FSM does the same thing as the WRITE FSM.
    75547531  // - The MULTI_ACK FSM complete those trasactions and erase the UPT entry.
    7555   // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
    7556   // - The XRAM_RSP FSM initiates an inval transactions and sets a new entry in UPT.
    7557   // - The CLEANUP  FSM decrement an entry in UPT.
    7558   // - The CAS FSM does the same thing as the WRITE FSM.
    75597532  // The resource is always allocated.
    75607533  /////////////////////////////////////////////////////////////////////////////////////
    7561 
    75627534  switch(r_alloc_upt_fsm.read())
    75637535  {
    7564       //////////////////////
    7565       case ALLOC_UPT_CONFIG:   // allocated to CONFIG FSM
    7566       if (r_config_fsm.read() != CONFIG_DIR_UPT_LOCK)
    7567       {
    7568         if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7569           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7570                
    7571         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7572                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7573           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7574 
    7575         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7576           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7577 
    7578         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7579           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7580 
    7581         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7582                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7583           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7584       }
    7585       break;
    7586 
    75877536      /////////////////////////
    7588       case ALLOC_UPT_MULTI_ACK:   // allocated to MULTI_ACK FSM
    7589       if( (r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK) and
    7590           (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
    7591       {
    7592         if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7593             (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7594           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7595 
    7596         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7597           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7598 
    7599         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7600           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7601 
    7602         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7603                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7604           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7605         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7606           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7607         else
    7608           m_cpt_upt_unused++;
    7609       }
    7610       else
    7611         m_cpt_multi_ack_fsm_upt_used++;
    7612       break;
    7613 
    7614       /////////////////////
    7615       case ALLOC_UPT_WRITE:   // allocated to WRITE FSM
    7616       if((r_write_fsm.read() != WRITE_UPT_LOCK) and
    7617           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
    7618       {
    7619         if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7620           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7621 
    7622         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7623           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7624 
    7625         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7626                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7627           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7628 
    7629         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7630           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7631 
    7632         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7633           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7634 
    7635         else
    7636           m_cpt_upt_unused++;
    7637       }
    7638       else
    7639         m_cpt_write_fsm_upt_used++;
    7640       break;
    7641 
    7642       ////////////////////////
    7643       case ALLOC_UPT_XRAM_RSP:
    7644       if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
    7645       {
    7646         if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7647           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7648 
    7649         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7650                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7651           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7652 
    7653         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7654           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7655 
    7656         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7657           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7658 
    7659         else if((r_write_fsm.read() == WRITE_UPT_LOCK)   or
    7660                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7661           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7662 
    7663         else
    7664           m_cpt_upt_unused++;
    7665       }
    7666       else
    7667         m_cpt_xram_rsp_fsm_upt_used++;
    7668       break;
    7669 
     7537      case ALLOC_UPT_WRITE:         // allocated to WRITE FSM
     7538          if (r_write_fsm.read() != WRITE_UPT_LOCK)
     7539          {
     7540              if (r_cas_fsm.read() == CAS_UPT_LOCK)
     7541                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     7542
     7543              else if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     7544                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     7545          }
     7546          break;
     7547
     7548      /////////////////////////
     7549      case ALLOC_UPT_CAS:           // allocated to CAS FSM
     7550          if (r_cas_fsm.read() != CAS_UPT_LOCK)
     7551          {
     7552              if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     7553                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     7554
     7555              else if (r_write_fsm.read() == WRITE_UPT_LOCK)
     7556                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     7557          }
     7558          break;
     7559
     7560      /////////////////////////
     7561      case ALLOC_UPT_MULTI_ACK:     // allocated to MULTI_ACK FSM
     7562          if ((r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK ) and
     7563              (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
     7564          {
     7565              if (r_write_fsm.read() == WRITE_UPT_LOCK)
     7566                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     7567
     7568              else if (r_cas_fsm.read() == CAS_UPT_LOCK)
     7569                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     7570          }
     7571          break;
     7572  } // end switch r_alloc_upt_fsm
     7573
     7574  ////////////////////////////////////////////////////////////////////////////////////
     7575  //    ALLOC_IVT FSM
     7576  ////////////////////////////////////////////////////////////////////////////////////
     7577  // The ALLOC_IVT FSM allocates the access to the Invalidate Table (IVT),
     7578  // with a round robin priority between five FSMs, with the following order:
     7579  //  WRITE -> XRAM_RSP -> CLEANUP -> CAS -> CONFIG
     7580  // - The WRITE FSM initiates broadcast invalidate transactions and sets a new entry
     7581  //   in IVT.
     7582  // - The CAS FSM does the same thing as the WRITE FSM.
     7583  // - The XRAM_RSP FSM initiates broadcast/multicast invalidate transaction and sets
     7584  //   a new entry in the IVT
     7585  // - The CONFIG FSM does the same thing as the XRAM_RSP FSM
     7586  // - The CLEANUP FSM complete those trasactions and erase the IVT entry.
     7587  // The resource is always allocated.
     7588  /////////////////////////////////////////////////////////////////////////////////////
     7589  switch(r_alloc_ivt_fsm.read())
     7590  {
    76707591      //////////////////////////
    7671       case ALLOC_UPT_CLEANUP:
    7672       if((r_cleanup_fsm.read() != CLEANUP_UPT_LOCK     ) and
    7673          (r_cleanup_fsm.read() != CLEANUP_UPT_DECREMENT))
    7674       {
    7675         if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7676             (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7677           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7678 
    7679         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7680           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7681 
    7682         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7683           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7684 
    7685         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7686                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7687           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7688 
    7689         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7690           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7691 
    7692         else
    7693           m_cpt_upt_unused++;
    7694       }
    7695       else
    7696         m_cpt_cleanup_fsm_upt_used++;
    7697       break;
     7592      case ALLOC_IVT_WRITE:            // allocated to WRITE FSM
     7593          if (r_write_fsm.read() != WRITE_BC_IVT_LOCK)
     7594          {
     7595              if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7596                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7597
     7598              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7599                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7600             
     7601              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7602                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7603             
     7604              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7605                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7606
     7607              else
     7608                  m_cpt_ivt_unused++;
     7609          }
     7610          break;
    76987611
    76997612      //////////////////////////
    7700       case ALLOC_UPT_CAS:
    7701       if((r_cas_fsm.read() != CAS_UPT_LOCK) and
    7702           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
    7703       {
    7704         if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7705           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7706 
    7707         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7708           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7709 
    7710         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7711                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7712           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7713 
    7714         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7715           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7716 
    7717         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7718           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7719 
    7720         else
    7721           m_cpt_upt_unused++;
    7722       }
    7723       else
    7724         m_cpt_cas_fsm_upt_used++;
    7725       break;
    7726 
    7727   } // end switch r_alloc_upt_fsm
     7613      case ALLOC_IVT_XRAM_RSP:         // allocated to XRAM_RSP FSM
     7614          if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
     7615          {
     7616            if(r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7617              r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7618
     7619            else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7620              r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7621
     7622            else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7623              r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7624
     7625            else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7626              r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7627
     7628            else
     7629              m_cpt_ivt_unused++;
     7630          }
     7631          break;
     7632
     7633      //////////////////////////
     7634      case ALLOC_IVT_CLEANUP:          // allocated to CLEANUP FSM
     7635          if ((r_cleanup_fsm.read() != CLEANUP_IVT_LOCK     ) and
     7636              (r_cleanup_fsm.read() != CLEANUP_IVT_DECREMENT))
     7637          {
     7638            if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7639              r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7640
     7641            else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7642              r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7643
     7644            else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7645              r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7646
     7647            else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7648              r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7649
     7650            else
     7651              m_cpt_ivt_unused++;
     7652          }
     7653          break;
     7654
     7655      //////////////////////////
     7656      case ALLOC_IVT_CAS:              // allocated to CAS FSM
     7657          if (r_cas_fsm.read() != CAS_BC_IVT_LOCK)
     7658          {
     7659            if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7660              r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7661
     7662            else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7663              r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7664
     7665            else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7666              r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7667
     7668            else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7669              r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7670     
     7671            else
     7672              m_cpt_ivt_unused++;
     7673          }
     7674          break;
     7675     
     7676      //////////////////////////
     7677      case ALLOC_IVT_CONFIG:           // allocated to CONFIG FSM
     7678          if (r_config_fsm.read() != CONFIG_DIR_IVT_LOCK)
     7679          {
     7680            if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7681              r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7682
     7683            else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7684              r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7685
     7686            else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7687              r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7688
     7689            else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7690              r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7691         
     7692            else
     7693              m_cpt_ivt_unused++;
     7694          }
     7695          break;
     7696
     7697  } // end switch r_alloc_ivt_fsm
    77287698
    77297699  ////////////////////////////////////////////////////////////////////////////////////
    … …  
    77557725    if ( (r_config_fsm.read()    != CONFIG_DIR_REQ) and
    77567726         (r_config_fsm.read()    != CONFIG_DIR_ACCESS) and
    7757          (r_config_fsm.read()    != CONFIG_DIR_UPT_LOCK) )
     7727         (r_config_fsm.read()    != CONFIG_DIR_IVT_LOCK) )
    77587728    {
    77597729        if(r_read_fsm.read() == READ_DIR_REQ)
    … …  
    78137783        (r_write_fsm.read()       != WRITE_DIR_HIT)  and
    78147784        (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  and
    7815         (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  and
     7785        (r_write_fsm.read()       != WRITE_BC_IVT_LOCK)  and
    78167786        (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  and
    78177787        (r_write_fsm.read()       != WRITE_UPT_LOCK)  and
    … …  
    78547824        (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  and
    78557825        (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  and
    7856         (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  and
     7826        (r_cas_fsm.read()         != CAS_BC_IVT_LOCK)  and
    78577827        (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  and
    78587828        (r_cas_fsm.read()         != CAS_UPT_LOCK)  and
    … …  
    79807950          r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    79817951
     7952        else if (r_ixr_cmd_fsm.read() == IXR_CMD_TRT_LOCK)
     7953          r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
     7954
    79827955        else
    79837956          m_cpt_trt_unused++;
    … …  
    79917964      if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
    79927965          (r_write_fsm.read() != WRITE_BC_TRT_LOCK) and
    7993           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
     7966          (r_write_fsm.read() != WRITE_BC_IVT_LOCK))
    79947967      {
    79957968        if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
    … …  
    80077980        else if (r_cleanup_fsm.read() == CLEANUP_IXR_REQ)
    80087981          r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
     7982       
     7983        else if (r_ixr_cmd_fsm.read() == IXR_CMD_TRT_LOCK)
     7984          r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    80097985
    80107986        else if(r_read_fsm.read() == READ_TRT_LOCK)
    … …  
    80227998      if((r_cas_fsm.read() != CAS_MISS_TRT_LOCK) and
    80237999          (r_cas_fsm.read() != CAS_BC_TRT_LOCK) and
    8024           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
     8000          (r_cas_fsm.read() != CAS_BC_IVT_LOCK))
    80258001      {
    80268002        if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    … …  
    80348010        else if (r_cleanup_fsm.read() == CLEANUP_IXR_REQ)
    80358011          r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
     8012       
     8013        else if (r_ixr_cmd_fsm.read() == IXR_CMD_TRT_LOCK)
     8014          r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    80368015
    80378016        else if(r_read_fsm.read() == READ_TRT_LOCK)
    … …  
    80638042        else if (r_cleanup_fsm.read() == CLEANUP_IXR_REQ)
    80648043          r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
     8044       
     8045        else if (r_ixr_cmd_fsm.read() == IXR_CMD_TRT_LOCK)
     8046          r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    80658047
    80668048        else if(r_read_fsm.read() == READ_TRT_LOCK)
    … …  
    80908072        if (r_cleanup_fsm.read() == CLEANUP_IXR_REQ)
    80918073          r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
     8074       
     8075        else if (r_ixr_cmd_fsm.read() == IXR_CMD_TRT_LOCK)
     8076          r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    80928077
    80938078        else if(r_read_fsm.read() == READ_TRT_LOCK)
    … …  
    81158100      ////////////////////////
    81168101    case ALLOC_TRT_CLEANUP:
    8117       if(r_ixr_rsp_fsm.read() != CLEANUP_IXR_REQ)
    8118       {
    8119         if(r_read_fsm.read() == READ_TRT_LOCK)
     8102      if(r_cleanup_fsm.read() != CLEANUP_IXR_REQ)
     8103      {
     8104        if (r_ixr_cmd_fsm.read() == IXR_CMD_TRT_LOCK)
     8105          r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
     8106       
     8107        else if(r_read_fsm.read() == READ_TRT_LOCK)
    81208108          r_alloc_trt_fsm = ALLOC_TRT_READ;
    81218109
    … …  
    81388126      break;
    81398127
     8128      ////////////////////////
     8129    case ALLOC_TRT_IXR_CMD:
     8130      if(r_ixr_cmd_fsm.read() != IXR_CMD_TRT_LOCK)
     8131      {
     8132        if(r_read_fsm.read() == READ_TRT_LOCK)
     8133          r_alloc_trt_fsm = ALLOC_TRT_READ;
     8134
     8135        else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) or
     8136                (r_write_fsm.read() == WRITE_BC_TRT_LOCK))
     8137          r_alloc_trt_fsm = ALLOC_TRT_WRITE;
     8138
     8139        else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
     8140                (r_cas_fsm.read() == CAS_BC_TRT_LOCK))
     8141          r_alloc_trt_fsm = ALLOC_TRT_CAS;
     8142
     8143        else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     8144                (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
     8145          r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
     8146
     8147        else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
     8148            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
     8149          r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
     8150       
     8151        else if (r_cleanup_fsm.read() == CLEANUP_IXR_REQ)
     8152          r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
     8153      }
     8154      break;
    81408155  } // end switch alloc_trt_fsm
    81418156
    … …  
    84068421  m_cc_receive_to_cleanup_fifo.update( cc_receive_to_cleanup_fifo_get,
    84078422                                       cc_receive_to_cleanup_fifo_put,
    8408                                        ( (uint64_t)(p_dspin_in.eop.read() & 0x1 ) << 32 ) | p_dspin_in.data.read() );
     8423                                       ( (uint64_t)(p_dspin_p2m.eop.read() & 0x1 ) << 32 ) | p_dspin_p2m.data.read() );
     8424
    84098425  ////////////////////////////////////////////////////////////////////////////////////
    84108426  //    CC_RECEIVE to MULTI_ACK FIFO
    … …  
    84138429  m_cc_receive_to_multi_ack_fifo.update( cc_receive_to_multi_ack_fifo_get,
    84148430                                         cc_receive_to_multi_ack_fifo_put,
    8415                                          p_dspin_in.data.read() );
     8431                                         p_dspin_p2m.data.read() );
    84168432
    84178433  ////////////////////////////////////////////////////////////////////////////////////
    … …  
    85628578    p_vci_ixr.address = (addr_t)((r_cleanup_to_ixr_cmd_nline.read() * m_words +
    85638579                                    r_ixr_cmd_cpt.read()) * 4);
     8580#if ODCCP_NON_INCLUSIVE
     8581    p_vci_ixr.wdata   = ((wide_data_t)(r_cleanup_to_ixr_cmd_data[r_ixr_cmd_cpt.read()].read()) |
     8582          ((wide_data_t)(r_cleanup_to_ixr_cmd_data[r_ixr_cmd_cpt.read() + 1].read()) << 32));
     8583#else
     8584    p_vci_ixr.wdata   = ((wide_data_t)(r_ixr_cmd_data[r_ixr_cmd_cpt.read()].read()) |
     8585          ((wide_data_t)(r_ixr_cmd_data[r_ixr_cmd_cpt.read() + 1].read()) << 32));
     8586#endif
    85648587   
     8588    /*
    85658589    if(r_cleanup_to_ixr_cmd_l1_dirty_ncc.read()) // if cleanup data contains data, we use cleanup_data buffer (cleanup dirty)
    85668590    {
    … …  
    85738597          ((wide_data_t)(r_xram_rsp_to_ixr_cmd_data[r_ixr_cmd_cpt.read() + 1].read()) << 32));
    85748598    }
    8575 
     8599    */
    85768600    p_vci_ixr.trdid   = r_cleanup_to_ixr_cmd_trdid.read();
    85778601    p_vci_ixr.eop     = (r_ixr_cmd_cpt == (m_words - 2));
    … …  
    87778801
    87788802  ////////////////////////////////////////////////////////////////////
    8779   //  p_dspin_out port (CC_SEND FSM)
     8803  //  p_dspin_m2p port (CC_SEND FSM)
    87808804  ////////////////////////////////////////////////////////////////////
    87818805
    8782   p_dspin_out.write = false;
    8783   p_dspin_out.eop   = false;
    8784   p_dspin_out.data  = 0;
     8806  p_dspin_m2p.write = false;
     8807  p_dspin_m2p.eop   = false;
     8808  p_dspin_m2p.data  = 0;
    87858809
    87868810  switch(r_cc_send_fsm.read())
    … …  
    87918815    case CC_SEND_WRITE_IDLE:
    87928816    case CC_SEND_CAS_IDLE:
    8793     case CC_SEND_CLEANUP_IDLE:
    87948817    {
    87958818        break;
    … …  
    88268849        DspinDhccpParam::dspin_set( flit,
    88278850                                    multi_inval_type,
    8828                                     DspinDhccpParam::FROM_MC_TYPE);
    8829         p_dspin_out.write = true;
    8830         p_dspin_out.data  = flit;
     8851                                    DspinDhccpParam::M2P_TYPE);
     8852        p_dspin_m2p.write = true;
     8853        p_dspin_m2p.data  = flit;
    88318854        break;
    88328855    }
    … …  
    88388861                                    r_config_to_cc_send_nline.read(),
    88398862                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8840         p_dspin_out.eop   = true;
    8841         p_dspin_out.write = true;
    8842         p_dspin_out.data  = flit;
     8863        p_dspin_m2p.eop   = true;
     8864        p_dspin_m2p.write = true;
     8865        p_dspin_m2p.data  = flit;
    88438866        break;
    88448867    }
    8845     ////////////////////////
    8846     case CC_SEND_CLEANUP_ACK:
    8847       {
    8848         uint8_t cleanup_ack_type;
    8849         if(r_cleanup_to_cc_send_inst.read())
    8850         {
    8851           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_INST;
    8852         }
    8853         else
    8854         {
    8855           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_DATA;
    8856         }
    8857 
    8858         uint64_t flit = 0;
    8859         uint64_t dest =
    8860           r_cleanup_to_cc_send_srcid.read() <<
    8861           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8862 
    8863         DspinDhccpParam::dspin_set(
    8864             flit,
    8865             dest,
    8866             DspinDhccpParam::CLEANUP_ACK_DEST);
    8867 
    8868         DspinDhccpParam::dspin_set(
    8869             flit,
    8870             r_cleanup_to_cc_send_set_index.read(),
    8871             DspinDhccpParam::CLEANUP_ACK_SET);
    8872 
    8873         DspinDhccpParam::dspin_set(
    8874             flit,
    8875             r_cleanup_to_cc_send_way_index.read(),
    8876             DspinDhccpParam::CLEANUP_ACK_WAY);
    8877 
    8878         DspinDhccpParam::dspin_set(
    8879             flit,
    8880             cleanup_ack_type,
    8881             DspinDhccpParam::FROM_MC_TYPE);
    8882 
    8883         p_dspin_out.eop   = true;
    8884         p_dspin_out.write = true;
    8885         p_dspin_out.data  = flit;
    8886 
    8887         break;
    8888     }
    8889 
    88908868    ///////////////////////////////////
    88918869    case CC_SEND_XRAM_RSP_INVAL_HEADER:
    … …  
    89218899        DspinDhccpParam::dspin_set( flit,
    89228900                                    multi_inval_type,
    8923                                     DspinDhccpParam::FROM_MC_TYPE);
    8924         p_dspin_out.write = true;
    8925         p_dspin_out.data  = flit;
     8901                                    DspinDhccpParam::M2P_TYPE);
     8902        p_dspin_m2p.write = true;
     8903        p_dspin_m2p.data  = flit;
    89268904        break;
    89278905    }
    … …  
    89358913                                    r_xram_rsp_to_cc_send_nline.read(),
    89368914                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8937         p_dspin_out.eop   = true;
    8938         p_dspin_out.write = true;
    8939         p_dspin_out.data  = flit;
     8915        p_dspin_m2p.eop   = true;
     8916        p_dspin_m2p.write = true;
     8917        p_dspin_m2p.data  = flit;
    89408918        break;
    89418919    }
    … …  
    89598937        DspinDhccpParam::dspin_set( flit,
    89608938                                    1ULL,
    8961                                     DspinDhccpParam::FROM_MC_BC);
    8962         p_dspin_out.write = true;
    8963         p_dspin_out.data  = flit;
     8939                                    DspinDhccpParam::M2P_BC);
     8940        p_dspin_m2p.write = true;
     8941        p_dspin_m2p.data  = flit;
    89648942        break;
    89658943    }
    … …  
    89718949                                    r_xram_rsp_to_cc_send_nline.read(),
    89728950                                    DspinDhccpParam::BROADCAST_NLINE);
    8973         p_dspin_out.write = true;
    8974         p_dspin_out.eop   = true;
    8975         p_dspin_out.data  = flit;
     8951        p_dspin_m2p.write = true;
     8952        p_dspin_m2p.eop   = true;
     8953        p_dspin_m2p.data  = flit;
    89768954        break;
    89778955    }
    … …  
    89838961                                    r_config_to_cc_send_nline.read(),
    89848962                                    DspinDhccpParam::BROADCAST_NLINE);
    8985         p_dspin_out.write = true;
    8986         p_dspin_out.eop   = true;
    8987         p_dspin_out.data  = flit;
     8963        p_dspin_m2p.write = true;
     8964        p_dspin_m2p.eop   = true;
     8965        p_dspin_m2p.data  = flit;
    89888966        break;
    89898967    }
    … …  
    89958973                                    r_write_to_cc_send_nline.read(),
    89968974                                    DspinDhccpParam::BROADCAST_NLINE);
    8997         p_dspin_out.write = true;
    8998         p_dspin_out.eop   = true;
    8999         p_dspin_out.data  = flit;
     8975        p_dspin_m2p.write = true;
     8976        p_dspin_m2p.eop   = true;
     8977        p_dspin_m2p.data  = flit;
    90008978        break;
    90018979    }
    … …  
    90078985                                    r_cas_to_cc_send_nline.read(),
    90088986                                    DspinDhccpParam::BROADCAST_NLINE);
    9009         p_dspin_out.write = true;
    9010         p_dspin_out.eop   = true;
    9011         p_dspin_out.data  = flit;
     8987        p_dspin_m2p.write = true;
     8988        p_dspin_m2p.eop   = true;
     8989        p_dspin_m2p.data  = flit;
    90128990        break;
    90138991    }
    … …  
    90509028            flit,
    90519029            multi_updt_type,
    9052             DspinDhccpParam::FROM_MC_TYPE);
    9053 
    9054         p_dspin_out.write = true;
    9055         p_dspin_out.data  = flit;
     9030            DspinDhccpParam::M2P_TYPE);
     9031
     9032        p_dspin_m2p.write = true;
     9033        p_dspin_m2p.data  = flit;
    90569034
    90579035        break;
    … …  
    90729050            DspinDhccpParam::MULTI_UPDT_NLINE);
    90739051
    9074         p_dspin_out.write = true;
    9075         p_dspin_out.data  = flit;
     9052        p_dspin_m2p.write = true;
     9053        p_dspin_m2p.data  = flit;
    90769054
    90779055        break;
    … …  
    90999077            DspinDhccpParam::MULTI_UPDT_DATA);
    91009078
    9101         p_dspin_out.write = true;
    9102         p_dspin_out.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
    9103         p_dspin_out.data  = flit;
     9079        p_dspin_m2p.write = true;
     9080        p_dspin_m2p.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
     9081        p_dspin_m2p.data  = flit;
    91049082
    91059083        break;
    … …  
    91439121            flit,
    91449122            multi_updt_type,
    9145             DspinDhccpParam::FROM_MC_TYPE);
    9146 
    9147         p_dspin_out.write = true;
    9148         p_dspin_out.data  = flit;
     9123            DspinDhccpParam::M2P_TYPE);
     9124
     9125        p_dspin_m2p.write = true;
     9126        p_dspin_m2p.data  = flit;
    91499127
    91509128        break;
    … …  
    91659143            DspinDhccpParam::MULTI_UPDT_NLINE);
    91669144
    9167         p_dspin_out.write = true;
    9168         p_dspin_out.data  = flit;
     9145        p_dspin_m2p.write = true;
     9146        p_dspin_m2p.data  = flit;
    91699147
    91709148        break;
    … …  
    91859163            DspinDhccpParam::MULTI_UPDT_DATA);
    91869164
    9187         p_dspin_out.write = true;
    9188         p_dspin_out.eop   = not r_cas_to_cc_send_is_long.read();
    9189         p_dspin_out.data  = flit;
     9165        p_dspin_m2p.write = true;
     9166        p_dspin_m2p.eop   = not r_cas_to_cc_send_is_long.read();
     9167        p_dspin_m2p.data  = flit;
    91909168
    91919169        break;
    … …  
    92069184            DspinDhccpParam::MULTI_UPDT_DATA);
    92079185
    9208         p_dspin_out.write = true;
    9209         p_dspin_out.eop   = true;
    9210         p_dspin_out.data  = flit;
     9186        p_dspin_m2p.write = true;
     9187        p_dspin_m2p.eop   = true;
     9188        p_dspin_m2p.data  = flit;
    92119189
    92129190        break;
    … …  
    92149192  }
    92159193
     9194  ////////////////////////////////////////////////////////////////////
     9195  //  p_dspin_clack port (CLEANUP FSM)
     9196  ////////////////////////////////////////////////////////////////////
     9197
     9198  switch(r_cleanup_fsm.read())
     9199  {
     9200    case CLEANUP_IDLE:
     9201    case CLEANUP_GET_NLINE:
     9202    case CLEANUP_DIR_REQ:
     9203    case CLEANUP_DIR_LOCK:
     9204    case CLEANUP_DIR_WRITE:
     9205    case CLEANUP_HEAP_REQ:
     9206    case CLEANUP_HEAP_LOCK:
     9207    case CLEANUP_HEAP_SEARCH:
     9208    case CLEANUP_HEAP_CLEAN:
     9209    case CLEANUP_HEAP_FREE:
     9210    case CLEANUP_IVT_LOCK:
     9211    case CLEANUP_IVT_DECREMENT:
     9212    case CLEANUP_IVT_CLEAR:
     9213    case CLEANUP_WRITE_RSP:
     9214    case CLEANUP_CONFIG_ACK:
     9215      p_dspin_clack.write = false;
     9216      p_dspin_clack.eop   = false;
     9217      p_dspin_clack.data  = 0;
     9218
     9219      break;
     9220
     9221    case CLEANUP_SEND_CLACK:
     9222      {
     9223        uint8_t cleanup_ack_type;
     9224        if(r_cleanup_inst.read())
     9225        {
     9226          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
     9227        }
     9228        else
     9229        {
     9230          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
     9231        }
     9232
     9233        uint64_t flit = 0;
     9234        uint64_t dest =
     9235          r_cleanup_srcid.read() <<
     9236          (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
     9237
     9238        DspinDhccpParam::dspin_set(
     9239            flit,
     9240            dest,
     9241            DspinDhccpParam::CLACK_DEST);
     9242
     9243        DspinDhccpParam::dspin_set(
     9244            flit,
     9245            r_cleanup_nline.read() & 0xFFFF,
     9246            DspinDhccpParam::CLACK_SET);
     9247
     9248        DspinDhccpParam::dspin_set(
     9249            flit,
     9250            r_cleanup_way_index.read(),
     9251            DspinDhccpParam::CLACK_WAY);
     9252
     9253        DspinDhccpParam::dspin_set(
     9254            flit,
     9255            cleanup_ack_type,
     9256            DspinDhccpParam::CLACK_TYPE);
     9257
     9258        p_dspin_clack.eop   = true;
     9259        p_dspin_clack.write = true;
     9260        p_dspin_clack.data  = flit;
     9261      }
     9262      break;
     9263  }
     9264
    92169265  ///////////////////////////////////////////////////////////////////
    9217   //  p_dspin_in port (CC_RECEIVE FSM)
     9266  //  p_dspin_p2m port (CC_RECEIVE FSM)
    92189267  ///////////////////////////////////////////////////////////////////
    9219   p_dspin_in.read = false;
     9268  //
    92209269  switch(r_cc_receive_fsm.read())
    92219270  {
    92229271    case CC_RECEIVE_IDLE:
    92239272      {
     9273        p_dspin_p2m.read = false;
    92249274        break;
    92259275      }
    … …  
    92279277    case CC_RECEIVE_CLEANUP_EOP:
    92289278      {
    9229         p_dspin_in.read = m_cc_receive_to_cleanup_fifo.wok();
     9279        p_dspin_p2m.read = m_cc_receive_to_cleanup_fifo.wok();
    92309280        break;
    92319281      }
    92329282    case CC_RECEIVE_MULTI_ACK:
    92339283      {
    9234         p_dspin_in.read = m_cc_receive_to_multi_ack_fifo.wok();
     9284        p_dspin_p2m.read = m_cc_receive_to_multi_ack_fifo.wok();
    92359285        break;
    92369286      }
Note: See TracChangeset for help on using the changeset viewer.