Ignore:
Timestamp:
Mar 29, 2013, 6:56:36 PM (11 years ago)
Author:
alain
Message:

New contructors for vci_mem_cache & vci_cc_vcache,
as we don't need anymore the mapping table for the coherence network...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/v5/modules/vci_mem_cache_dspin_coherence/caba/source/src/vci_mem_cache_dspin_coherence.cpp

    r339 r346  
    11/* -*- c++ -*-
     2*
    23* File       : vci_mem_cache.cpp
    34* Date       : 30/10/2008
    … …  
    275276  VciMemCache<vci_param>
    276277
    277 using soclib::common::uint32_log2;
     278using namespace soclib::common;
    278279
    279280////////////////////////////////
    … …  
    282283
    283284tmpl(/**/) ::VciMemCache(
    284   sc_module_name name,
    285   const soclib::common::MappingTable &mtp,
    286   const soclib::common::MappingTable &mtc,
    287   const soclib::common::MappingTable &mtx,
    288   const soclib::common::IntTab &vci_ixr_index,
    289   const soclib::common::IntTab &vci_ini_index,
    290   const soclib::common::IntTab &vci_tgt_index,
    291   const soclib::common::IntTab &vci_tgt_index_cleanup,
    292   size_t nways,                 // number of ways per set
    293   size_t nsets,                 // number of cache sets
    294   size_t nwords,                // number of words in cache line
    295   size_t heap_size,             // number of heap entries
    296   size_t transaction_tab_lines, // number of TRT entries
    297   size_t update_tab_lines,      // number of UPT entries
    298   size_t debug_start_cycle,
    299   bool   debug_ok)
     285  sc_module_name      name,
     286  const MappingTable  &mtp,              // mapping table for direct network
     287  const MappingTable  &mtx,              // mapping table for external network
     288  const IntTab        &srcid_x,          // global index on external network
     289  const IntTab        &tgtid_d,          // global index on direct network
     290  const size_t        cc_global_id,      // global index on cc network
     291  const size_t        nways,             // number of ways per set
     292  const size_t        nsets,             // number of associative sets
     293  const size_t        nwords,            // number of words in cache line
     294  const size_t        max_copies,        // max number of copies in heap
     295  const size_t        heap_size,         // number of heap entries
     296  const size_t        trt_lines,         // number of TRT entries
     297  const size_t        upt_lines,         // number of UPT entries
     298  const size_t        debug_start_cycle,
     299  const bool          debug_ok)
    300300
    301301  : soclib::caba::BaseModule(name),
    302302
    303     m_debug_start_cycle(debug_start_cycle),
    304     m_debug_ok(debug_ok),
    305 
    306     p_clk("clk"),
    307     p_resetn("resetn"),
    308     p_vci_tgt("vci_tgt"),
    309     p_vci_ixr("vci_ixr"),
    310     p_dspin_in("dspin_tgt"),
    311     p_dspin_out("cc_send"),
    312 
    313     m_seglist(mtp.getSegmentList(vci_tgt_index)),
    314     m_cseglist(mtc.getSegmentList(vci_tgt_index_cleanup)),
    315 
    316     m_initiators(1 << vci_param::S),
    317     m_heap_size(heap_size),
    318     m_ways(nways),
    319     m_sets(nsets),
    320     m_words(nwords),
    321     m_srcid_ixr(mtx.indexForId(vci_ixr_index)),
    322     m_srcid_ini(mtc.indexForId(vci_ini_index)),
    323     m_transaction_tab_lines(transaction_tab_lines),
    324     m_transaction_tab(transaction_tab_lines, nwords),
    325     m_update_tab_lines(update_tab_lines),
    326     m_update_tab(update_tab_lines),
     303    p_clk( "p_clk" ),
     304    p_resetn( "p_resetn" ),
     305    p_vci_tgt( "p_vci_tgt" ),
     306    p_vci_ixr( "p_vci_ixr" ),
     307    p_dspin_in( "p_dspin_in" ),
     308    p_dspin_out( "p_dspin_out" ),
     309
     310    m_seglist( mtp.getSegmentList(tgtid_d) ),
     311    m_nseg( 0 ),
     312    m_srcid_x( mtx.indexForId(srcid_x) ),
     313    m_initiators( 1 << vci_param::S ),
     314    m_heap_size( heap_size ),
     315    m_ways( nways ),
     316    m_sets( nsets ),
     317    m_words( nwords ),
     318    m_cc_global_id( cc_global_id ),
     319    m_debug_start_cycle( debug_start_cycle ),
     320    m_debug_ok( debug_ok ),
     321    m_trt_lines(trt_lines),
     322    m_trt(trt_lines, nwords),
     323    m_upt_lines(upt_lines),
     324    m_upt(upt_lines),
    327325    m_cache_directory(nways, nsets, nwords, vci_param::N),
    328326    m_cache_data(nways, nsets, nwords),
    329327    m_heap(m_heap_size),
     328    m_max_copies( max_copies ),
    330329    m_llsc_table(),
    331330
    … …  
    368367    r_tgt_cmd_fsm("r_tgt_cmd_fsm"),
    369368
    370     m_nseg(0),
    371     m_ncseg(0),
    372 
    373369    r_read_fsm("r_read_fsm"),
    374370
    … …  
    416412    r_alloc_heap_reset_cpt("r_alloc_heap_reset_cpt")
    417413{
    418   assert(IS_POW_OF_2(nsets));
    419   assert(IS_POW_OF_2(nwords));
    420   assert(IS_POW_OF_2(nways));
    421   assert(nsets);
    422   assert(nwords);
    423   assert(nways);
    424 
    425   // check Transaction table size
    426   assert((uint32_log2(transaction_tab_lines) <= vci_param::T) and
     414    assert(IS_POW_OF_2(nsets));
     415    assert(IS_POW_OF_2(nwords));
     416    assert(IS_POW_OF_2(nways));
     417    assert(nsets);
     418    assert(nwords);
     419    assert(nways);
     420
     421    // check Transaction table size
     422    assert((uint32_log2(trt_lines) <= vci_param::T) and
    427423         "Need more bits for VCI TRDID field");
    428424
    429   // Get the segments associated to the MemCache
    430   std::list<soclib::common::Segment>::iterator seg;
    431   size_t i;
    432 
    433   for(seg = m_seglist.begin(); seg != m_seglist.end() ; seg++)
    434   {
    435     m_nseg++;
    436   }
    437   for(seg = m_cseglist.begin(); seg != m_cseglist.end() ; seg++)
    438   {
    439     m_ncseg++;
    440   }
    441 
    442   m_seg = new soclib::common::Segment*[m_nseg];
    443 
    444   i = 0;
    445   for(seg = m_seglist.begin() ; seg != m_seglist.end() ; seg++)
    446   {
    447     m_seg[i] = & (*seg);
    448     i++;
    449   }
    450 
    451   m_cseg = new soclib::common::Segment*[m_ncseg];
    452 
    453   i = 0;
    454   for(seg = m_cseglist.begin() ; seg != m_cseglist.end() ; seg++)
    455   {
    456     m_cseg[i] = & (*seg);
    457     i++;
    458   }
    459 
    460   // Allocation for IXR_RSP FSM
    461   r_ixr_rsp_to_xram_rsp_rok  = new sc_signal<bool>[m_transaction_tab_lines];
    462 
    463   // Allocation for XRAM_RSP FSM
    464   r_xram_rsp_victim_data     = new sc_signal<data_t>[nwords];
    465   r_xram_rsp_to_tgt_rsp_data = new sc_signal<data_t>[nwords];
    466   r_xram_rsp_to_ixr_cmd_data = new sc_signal<data_t>[nwords];
    467 
    468   // Allocation for READ FSM
    469   r_read_data                = new sc_signal<data_t>[nwords];
    470   r_read_to_tgt_rsp_data     = new sc_signal<data_t>[nwords];
    471 
    472   // Allocation for WRITE FSM
    473   r_write_data               = new sc_signal<data_t>[nwords];
    474   r_write_be                 = new sc_signal<be_t>[nwords];
    475   r_write_to_cc_send_data    = new sc_signal<data_t>[nwords];
    476   r_write_to_cc_send_be      = new sc_signal<be_t>[nwords];
    477   r_write_to_ixr_cmd_data    = new sc_signal<data_t>[nwords];
    478 
    479   // Allocation for CAS FSM
    480   r_cas_to_ixr_cmd_data      = new sc_signal<data_t>[nwords];
    481   r_cas_data                 = new sc_signal<data_t>[nwords];
    482   r_cas_rdata                = new sc_signal<data_t>[2];
    483 
    484 
    485   // Simulation
    486 
    487   SC_METHOD(transition);
    488   dont_initialize();
    489   sensitive << p_clk.pos();
    490 
    491   SC_METHOD(genMoore);
    492   dont_initialize();
    493   sensitive << p_clk.neg();
     425    // Get the segments associated to the MemCache
     426    std::list<soclib::common::Segment>::iterator seg;
     427    size_t i = 0;
     428
     429    for(seg = m_seglist.begin(); seg != m_seglist.end() ; seg++)
     430    {
     431        m_nseg++;
     432    }
     433
     434    m_seg = new soclib::common::Segment*[m_nseg];
     435
     436    for(seg = m_seglist.begin() ; seg != m_seglist.end() ; seg++)
     437    {
     438        m_seg[i] = & (*seg);
     439        i++;
     440    }
     441
     442    // Allocation for IXR_RSP FSM
     443    r_ixr_rsp_to_xram_rsp_rok  = new sc_signal<bool>[m_trt_lines];
     444
     445    // Allocation for XRAM_RSP FSM
     446    r_xram_rsp_victim_data     = new sc_signal<data_t>[nwords];
     447    r_xram_rsp_to_tgt_rsp_data = new sc_signal<data_t>[nwords];
     448    r_xram_rsp_to_ixr_cmd_data = new sc_signal<data_t>[nwords];
     449
     450    // Allocation for READ FSM
     451    r_read_data                = new sc_signal<data_t>[nwords];
     452    r_read_to_tgt_rsp_data     = new sc_signal<data_t>[nwords];
     453
     454    // Allocation for WRITE FSM
     455    r_write_data               = new sc_signal<data_t>[nwords];
     456    r_write_be                 = new sc_signal<be_t>[nwords];
     457    r_write_to_cc_send_data    = new sc_signal<data_t>[nwords];
     458    r_write_to_cc_send_be      = new sc_signal<be_t>[nwords];
     459    r_write_to_ixr_cmd_data    = new sc_signal<data_t>[nwords];
     460
     461    // Allocation for CAS FSM
     462    r_cas_to_ixr_cmd_data      = new sc_signal<data_t>[nwords];
     463    r_cas_data                 = new sc_signal<data_t>[nwords];
     464    r_cas_rdata                = new sc_signal<data_t>[2];
     465
     466
     467    SC_METHOD(transition);
     468    dont_initialize();
     469    sensitive << p_clk.pos();
     470
     471    SC_METHOD(genMoore);
     472    dont_initialize();
     473    sensitive << p_clk.neg();
    494474} // end constructor
    495475
    … …  
    580560  std::cout << "----------------------------------" << std::dec << std::endl;
    581561  std::cout
    582       << "MEM_CACHE " << m_srcid_ini << " / Time = " << m_cpt_cycles << std::endl
     562      << "MEM_CACHE " << name() << " / Time = " << m_cpt_cycles << std::endl
    583563      << "- READ RATE            = " << (double) m_cpt_read/m_cpt_cycles << std::endl
    584564      << "- READ TOTAL           = " << m_cpt_read << std::endl
    … …  
    666646
    667647    //  Initializing Tables
    668     m_transaction_tab.init();
    669     m_update_tab.init();
     648    m_trt.init();
     649    m_upt.init();
    670650    m_llsc_table.init();
    671651
    … …  
    728708#endif
    729709
    730     for(size_t i=0; i<m_transaction_tab_lines ; i++)
     710    for(size_t i=0; i<m_trt_lines ; i++)
    731711    {
    732712      r_ixr_rsp_to_xram_rsp_rok[i] = false;
    … …  
    748728    r_alloc_dir_reset_cpt  = 0;
    749729    r_alloc_heap_reset_cpt = 0;
    750 
    751     r_copies_limit         = 3;
    752730
    753731    // Activity counters
    … …  
    835813    std::cout
    836814        << "---------------------------------------------"           << std::dec << std::endl
    837         << "MEM_CACHE "            << m_srcid_ini
     815        << "MEM_CACHE "            << name()
    838816        << " ; Time = "            << m_cpt_cycles                                << std::endl
    839817        << " - TGT_CMD FSM    = "  << tgt_cmd_fsm_str[r_tgt_cmd_fsm.read()]       << std::endl
    … …  
    11391117          (DspinDhccpParam::dspin_get(flit, DspinDhccpParam::FROM_L1_EOP) == 0x1);
    11401118
    1141         if(updt_index >= m_update_tab.size())
     1119        if(updt_index >= m_upt.size())
    11421120        {
    11431121          std::cout
    … …  
    11471125            << std::dec
    11481126            << " / UPT index = " << updt_index
    1149             << " / UPT size = "  << m_update_tab.size()
     1127            << " / UPT size = "  << m_upt.size()
    11501128            << std::endl;
    11511129
    … …  
    11881166        // decrement the number of expected responses
    11891167        size_t count = 0;
    1190         bool valid   = m_update_tab.decrement(r_multi_ack_upt_index.read(), count);
     1168        bool valid   = m_upt.decrement(r_multi_ack_upt_index.read(), count);
    11911169
    11921170        if(not valid)
    … …  
    12371215        }
    12381216
    1239         r_multi_ack_srcid = m_update_tab.srcid(r_multi_ack_upt_index.read());
    1240         r_multi_ack_trdid = m_update_tab.trdid(r_multi_ack_upt_index.read());
    1241         r_multi_ack_pktid = m_update_tab.pktid(r_multi_ack_upt_index.read());
    1242         r_multi_ack_nline = m_update_tab.nline(r_multi_ack_upt_index.read());
    1243         bool need_rsp     = m_update_tab.need_rsp(r_multi_ack_upt_index.read());
     1217        r_multi_ack_srcid = m_upt.srcid(r_multi_ack_upt_index.read());
     1218        r_multi_ack_trdid = m_upt.trdid(r_multi_ack_upt_index.read());
     1219        r_multi_ack_pktid = m_upt.pktid(r_multi_ack_upt_index.read());
     1220        r_multi_ack_nline = m_upt.nline(r_multi_ack_upt_index.read());
     1221        bool need_rsp     = m_upt.need_rsp(r_multi_ack_upt_index.read());
    12441222
    12451223        // clear the UPT entry
    1246         m_update_tab.clear(r_multi_ack_upt_index.read());
     1224        m_upt.clear(r_multi_ack_upt_index.read());
    12471225
    12481226        if(need_rsp)
    … …  
    15701548      {
    15711549        // enter counter mode when we reach the limit of copies or the heap is full
    1572         bool go_cnt = (r_read_count.read() >= r_copies_limit.read()) || m_heap.is_full();
     1550        bool go_cnt = (r_read_count.read() >= m_max_copies) || m_heap.is_full();
    15731551
    15741552        // read data in the cache
    … …  
    18131791        size_t      index     = 0;
    18141792        vci_addr_t  addr      = (vci_addr_t) m_cmd_read_addr_fifo.read();
    1815         bool        hit_read  = m_transaction_tab.hit_read(m_nline[addr], index);
    1816         bool        hit_write = m_transaction_tab.hit_write(m_nline[addr]);
    1817         bool        wok       = !m_transaction_tab.full(index);
     1793        bool        hit_read  = m_trt.hit_read(m_nline[addr], index);
     1794        bool        hit_write = m_trt.hit_write(m_nline[addr]);
     1795        bool        wok       = !m_trt.full(index);
    18181796
    18191797        if(hit_read || !wok || hit_write)    // missing line already requested or no space
    … …  
    18481826      if(r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
    18491827      {
    1850         m_transaction_tab.set(r_read_trt_index.read(),
     1828        m_trt.set(r_read_trt_index.read(),
    18511829                              true,
    18521830                              m_nline[(vci_addr_t)(m_cmd_read_addr_fifo.read())],
    … …  
    23012279        size_t      way        = r_write_way.read();
    23022280
    2303         wok = m_update_tab.set(true,  // it's an update transaction
     2281        wok = m_upt.set(true,  // it's an update transaction
    23042282                               false,    // it's not a broadcast
    23052283                               true,     // it needs a response
    … …  
    26202598        size_t  wok_index = 0;
    26212599        vci_addr_t  addr  = (vci_addr_t) r_write_address.read();
    2622         bool    hit_read  = m_transaction_tab.hit_read(m_nline[addr], hit_index);
    2623         bool    hit_write = m_transaction_tab.hit_write(m_nline[addr]);
    2624         bool    wok       = !m_transaction_tab.full(wok_index);
     2600        bool    hit_read  = m_trt.hit_read(m_nline[addr], hit_index);
     2601        bool    hit_write = m_trt.hit_write(m_nline[addr]);
     2602        bool    wok       = !m_trt.full(wok_index);
    26252603
    26262604        if(hit_read)      // register the modified data in TRT
    … …  
    26722650          data_vector.push_back(r_write_data[i]);
    26732651        }
    2674         m_transaction_tab.set(r_write_trt_index.read(),
     2652        m_trt.set(r_write_trt_index.read(),
    26752653                              true,     // read request to XRAM
    26762654                              m_nline[(vci_addr_t)(r_write_address.read())],
    … …  
    27092687          data_vector.push_back(r_write_data[i]);
    27102688        }
    2711         m_transaction_tab.write_data_mask(r_write_trt_index.read(),
     2689        m_trt.write_data_mask(r_write_trt_index.read(),
    27122690                                          be_vector,
    27132691                                          data_vector);
    … …  
    27182696        {
    27192697          std::cout << "  <MEMC " << name() << ".WRITE_MISS_TRT_DATA> Modify an existing entry in TRT" << std::endl;
    2720           m_transaction_tab.print(r_write_trt_index.read());
     2698          m_trt.print(r_write_trt_index.read());
    27212699        }
    27222700#endif
    … …  
    27522730      {
    27532731        size_t wok_index = 0;
    2754         bool wok = !m_transaction_tab.full(wok_index);
     2732        bool wok = !m_trt.full(wok_index);
    27552733        if(wok)       // set a new entry in TRT
    27562734        {
    … …  
    27872765        size_t      nb_copies = r_write_count.read();
    27882766
    2789         wok =m_update_tab.set(false,  // it's an inval transaction
     2767        wok =m_upt.set(false,  // it's an inval transaction
    27902768                              true,     // it's a broadcast
    27912769                              true,     // it needs a response
    … …  
    28302808
    28312809      // register a write request to XRAM in TRT
    2832       m_transaction_tab.set(r_write_trt_index.read(),
     2810      m_trt.set(r_write_trt_index.read(),
    28332811                            false,    // write request to XRAM
    28342812                            m_nline[(vci_addr_t)(r_write_address.read())],
    … …  
    31603138      if(r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
    31613139      {
    3162         m_transaction_tab.erase(r_ixr_rsp_trt_index.read());
     3140        m_trt.erase(r_ixr_rsp_trt_index.read());
    31633141        r_ixr_rsp_fsm = IXR_RSP_IDLE;
    31643142
    … …  
    31843162        assert(((eop == (r_ixr_rsp_cpt.read() == (m_words-1))) || p_vci_ixr.rerror.read())
    31853163               and "Error in VCI_MEM_CACHE : invalid length for a response from XRAM");
    3186         m_transaction_tab.write_rsp(index,
     3164        m_trt.write_rsp(index,
    31873165                                    r_ixr_rsp_cpt.read(),
    31883166                                    data,
    … …  
    32383216    {
    32393217      size_t ptr   = r_xram_rsp_trt_index.read();
    3240       size_t lines = m_transaction_tab_lines;
     3218      size_t lines = m_trt_lines;
    32413219      for(size_t i=0 ; i<lines ; i++)
    32423220      {
    … …  
    32723250        size_t  index = r_xram_rsp_trt_index.read();
    32733251
    3274         TransactionTabEntry trt_entry(m_transaction_tab.read(index));
     3252        TransactionTabEntry trt_entry(m_trt.read(index));
    32753253        r_xram_rsp_trt_buf.copy(trt_entry);  // TRT entry local buffer
    32763254
    … …  
    33523330      {
    33533331        size_t index;
    3354         if(m_update_tab.search_inval(r_xram_rsp_trt_buf.nline, index))
     3332        if(m_upt.search_inval(r_xram_rsp_trt_buf.nline, index))
    33553333        {
    33563334          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    … …  
    33613339            std::cout << "  <MEMC " << name() << ".XRAM_RSP_INVAL_LOCK> Get acces to UPT,"
    33623340                      << " but an invalidation is already registered at this address" << std::endl;
    3363             m_update_tab.print();
     3341            m_upt.print();
    33643342          }
    33653343#endif
    33663344
    33673345        }
    3368         else if(m_update_tab.is_full() && r_xram_rsp_victim_inval.read())
     3346        else if(m_upt.is_full() && r_xram_rsp_victim_inval.read())
    33693347        {
    33703348          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    … …  
    33753353            std::cout << "  <MEMC " << name() << ".XRAM_RSP_INVAL_LOCK> Get acces to UPT,"
    33763354                      << " but the table is full" << std::endl;
    3377             m_update_tab.print();
     3355            m_upt.print();
    33783356          }
    33793357#endif
    … …  
    34633441        size_t count_copies   = r_xram_rsp_victim_count.read();
    34643442
    3465         bool   wok = m_update_tab.set(false,      // it's an inval transaction
     3443        bool   wok = m_upt.set(false,      // it's an inval transaction
    34663444                                      brdcast,  // set brdcast bit
    34673445                                      false,    // it does not need a response
    … …  
    35013479      // If the victim is not dirty, we don't need another XRAM  put transaction,
    35023480      // and we canwe erase the TRT entry
    3503       if(!r_xram_rsp_victim_dirty.read())  m_transaction_tab.erase(r_xram_rsp_trt_index.read());
     3481      if(!r_xram_rsp_victim_dirty.read())  m_trt.erase(r_xram_rsp_trt_index.read());
    35043482
    35053483      // Next state
    … …  
    35153493      if(r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP)
    35163494      {
    3517         m_transaction_tab.set(r_xram_rsp_trt_index.read(),
     3495        m_trt.set(r_xram_rsp_trt_index.read(),
    35183496                              false,       // write to XRAM
    35193497                              r_xram_rsp_victim_nline.read(),  // line index
    … …  
    37403718    case XRAM_RSP_ERROR_ERASE:  // erase TRT entry in case of error
    37413719    {
    3742       m_transaction_tab.erase(r_xram_rsp_trt_index.read());
     3720      m_trt.erase(r_xram_rsp_trt_index.read());
    37433721
    37443722      // Next state
    … …  
    44354413      bool   match_inval;
    44364414
    4437       match_inval = m_update_tab.search_inval(r_cleanup_nline.read(), index);
     4415      match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
    44384416
    44394417      // no pending inval
    … …  
    44584436
    44594437      // pending inval
    4460       r_cleanup_write_srcid    = m_update_tab.srcid(index);
    4461       r_cleanup_write_trdid    = m_update_tab.trdid(index);
    4462       r_cleanup_write_pktid    = m_update_tab.pktid(index);
    4463       r_cleanup_write_need_rsp = m_update_tab.need_rsp(index);
     4438      r_cleanup_write_srcid    = m_upt.srcid(index);
     4439      r_cleanup_write_trdid    = m_upt.trdid(index);
     4440      r_cleanup_write_pktid    = m_upt.pktid(index);
     4441      r_cleanup_write_need_rsp = m_upt.need_rsp(index);
    44644442      r_cleanup_index          = index;
    44654443
    … …  
    44974475
    44984476      size_t count = 0;
    4499       m_update_tab.decrement(r_cleanup_index.read(), count);
     4477      m_upt.decrement(r_cleanup_index.read(), count);
    45004478
    45014479      // invalidation transaction finished
    … …  
    45394517      }
    45404518
    4541       m_update_tab.clear(r_cleanup_index.read());
     4519      m_upt.clear(r_cleanup_index.read());
    45424520
    45434521      if(r_cleanup_write_need_rsp.read())
    … …  
    49194897        size_t      nb_copies  = r_cas_count.read();
    49204898
    4921         wok = m_update_tab.set(true,  // it's an update transaction
     4899        wok = m_upt.set(true,  // it's an update transaction
    49224900                               false,   // it's not a broadcast
    49234901                               true,    // it needs a response
    … …  
    51255103          }
    51265104          size_t wok_index = 0;
    5127           bool   wok       = !m_transaction_tab.full(wok_index);
     5105          bool   wok       = !m_trt.full(wok_index);
    51285106          if(wok)
    51295107          {
    … …  
    51585136
    51595137        // register a broadcast inval transaction in UPT
    5160         wok = m_update_tab.set(false,  // it's an inval transaction
     5138        wok = m_upt.set(false,  // it's an inval transaction
    51615139                               true,    // it's a broadcast
    51625140                               true,    // it needs a response
    … …  
    52165194      {
    52175195        // set TRT
    5218         m_transaction_tab.set(r_cas_trt_index.read(),
     5196        m_trt.set(r_cas_trt_index.read(),
    52195197                              false,    // PUT request to XRAM
    52205198                              m_nline[(vci_addr_t)(m_cmd_cas_addr_fifo.read())],
    … …  
    53615339      {
    53625340        size_t   index = 0;
    5363         bool hit_read = m_transaction_tab.hit_read(
     5341        bool hit_read = m_trt.hit_read(
    53645342                          m_nline[(vci_addr_t) m_cmd_cas_addr_fifo.read()],index);
    5365         bool hit_write = m_transaction_tab.hit_write(
     5343        bool hit_write = m_trt.hit_write(
    53665344                           m_nline[(vci_addr_t) m_cmd_cas_addr_fifo.read()]);
    5367         bool wok = !m_transaction_tab.full(index);
     5345        bool wok = !m_trt.full(index);
    53685346
    53695347#if DEBUG_MEMC_CAS
    … …  
    54055383        }
    54065384
    5407         m_transaction_tab.set(r_cas_trt_index.read(),
     5385        m_trt.set(r_cas_trt_index.read(),
    54085386                              true,   // read request
    54095387                              m_nline[(vci_addr_t) m_cmd_cas_addr_fifo.read()],
    … …  
    71627140  p_vci_ixr.be      = 0xF;
    71637141  p_vci_ixr.pktid   = 0;
    7164   p_vci_ixr.srcid   = m_srcid_ixr;
     7142  p_vci_ixr.srcid   = m_srcid_x;
    71657143  p_vci_ixr.cons    = false;
    71667144  p_vci_ixr.wrap    = false;
    … …  
    72887266  // Response signals on the p_vci_tgt port
    72897267  ////////////////////////////////////////////////////
     7268
    72907269  switch(r_tgt_rsp_fsm.read())
    72917270  {
    … …  
    73847363  // Initiator command signals on the p_dspin_out port (CC_SEND FSM)
    73857364  ////////////////////////////////////////////////////////////////////
     7365
    73867366  p_dspin_out.write = false;
    73877367  p_dspin_out.data  = 0;
    … …  
    73897369  switch(r_cc_send_fsm.read())
    73907370  {
     7371 
    73917372    case CC_SEND_XRAM_RSP_IDLE:
    73927373    case CC_SEND_WRITE_IDLE:
    … …  
    74637444        DspinDhccpParam::dspin_set(
    74647445            flit,
    7465             m_srcid_ini,
     7446            m_cc_global_id,
    74667447            DspinDhccpParam::MULTI_INVAL_SRCID);
    74677448
    … …  
    75167497        DspinDhccpParam::dspin_set(
    75177498            flit,
    7518             m_srcid_ini,
     7499            m_cc_global_id,
    75197500            DspinDhccpParam::BROADCAST_SRCID);
    75207501
    … …  
    76137594        DspinDhccpParam::dspin_set(
    76147595            flit,
    7615             m_srcid_ini,
     7596            m_cc_global_id,
    76167597            DspinDhccpParam::MULTI_UPDT_SRCID);
    76177598
    … …  
    77177698        DspinDhccpParam::dspin_set(
    77187699            flit,
    7719             m_srcid_ini,
     7700            m_cc_global_id,
    77207701            DspinDhccpParam::MULTI_UPDT_SRCID);
    77217702
Note: See TracChangeset for help on using the changeset viewer.