Changeset 82 for trunk


Ignore:
Timestamp:
Sep 2, 2010, 2:22:12 PM (14 years ago)
Author:
guthmull
Message:

Add broadcast limitation compatibility, indicate the type of response when possible

Location:
trunk/modules
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r2 r82  
    434434
    435435                    // multi-update or multi-invalidate for data type
    436                     if ( (address != 0x3) && (! m_segment.contains(address)) )
     436                    if ( ((address&0x3) != 0x3) && (! m_segment.contains(address)) )
    437437                    {
    438438                        std::cout << "error in component VCI_CC_XCACHE_WRAPPER " << name() << std::endl;
    … …  
    448448                    r_tgt_plen  = p_vci_tgt.plen.read();
    449449                   
    450                     if ( address == 0x3 )   // broadcast invalidate for data or instruction type
     450                    if ( (address&0x3) == 0x3 )   // broadcast invalidate for data or instruction type
    451451                    {
    452452                        if ( ! p_vci_tgt.eop.read() )
    … …  
    14871487                    r_vci_rsp_fsm = RSP_IDLE;
    14881488                }
    1489                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
     1489                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
    14901490                break;
    14911491
    … …  
    14991499                r_vci_rsp_fsm = RSP_IDLE;
    15001500                r_icache_unc_req = false;
    1501                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
     1501                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
    15021502                break;
    15031503
    … …  
    15161516                    r_vci_rsp_fsm = RSP_IDLE;
    15171517                }
    1518                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
     1518                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
    15191519                break;
    15201520
    … …  
    15271527                    r_dcache_write_req = false;
    15281528                }
    1529                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) m_iss.setWriteBerr();
     1529                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) m_iss.setWriteBerr();
    15301530                break;
    15311531
    … …  
    15391539                r_vci_rsp_fsm = RSP_IDLE;
    15401540                r_dcache_unc_req = false;
    1541                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
     1541                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
    15421542                break;
    15431543
    … …  
    15481548                assert( p_vci_ini_c.reop.read() &&
    15491549                        "illegal VCI response packet for icache cleanup");
    1550                 assert( (p_vci_ini_c.rerror.read() == vci_param::ERR_NORMAL) &&
     1550                assert( ((p_vci_ini_c.rerror.read()&0x1) == vci_param::ERR_NORMAL) &&
    15511551                        "error in response packet for icache cleanup");
    15521552                if ( r_vci_rsp_fsm == RSP_INS_CLEANUP ) r_icache_cleanup_req = false;
    … …  
    18871887                p_vci_tgt.rtrdid  = r_tgt_trdid.read();
    18881888                p_vci_tgt.rdata   = 0;
    1889                 p_vci_tgt.rerror  = 0;
     1889                p_vci_tgt.rerror  = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    18901890                p_vci_tgt.reop    = true;
    18911891                break;
    … …  
    18981898                p_vci_tgt.rtrdid  = r_tgt_trdid.read();
    18991899                p_vci_tgt.rdata   = 0;
    1900                 p_vci_tgt.rerror  = 0;
     1900                p_vci_tgt.rerror  = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    19011901                p_vci_tgt.reop    = true;
    19021902                break;
    … …  
    19091909                p_vci_tgt.rtrdid  = r_tgt_trdid.read();
    19101910                p_vci_tgt.rdata   = 0;
    1911                 p_vci_tgt.rerror  = 0;
     1911                p_vci_tgt.rerror  = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    19121912                p_vci_tgt.reop    = true;
    19131913                break;

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

    r58 r82  
    432432
    433433                    // multi-update or multi-invalidate for data type
    434                     if ( (address != 0x3) && (! m_segment.contains(address)) )
     434                    if ( ((address&0x3) != 0x3) && (! m_segment.contains(address)) )
    435435                    {
    436436                        std::cout << "error in component VCI_CC_XCACHE_WRAPPER " << name() << std::endl;
    … …  
    446446                    r_tgt_plen  = p_vci_tgt.plen.read();
    447447                   
    448                     if ( address == 0x3 )   // broadcast invalidate for data or instruction type
     448                    if ( (address&0x3) == 0x3 )   // broadcast invalidate for data or instruction type
    449449                    {
    450450                        if ( ! p_vci_tgt.eop.read() )
    … …  
    15581558                    r_vci_rsp_fsm = RSP_IDLE;
    15591559                }
    1560                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
     1560                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
    15611561                break;
    15621562
    … …  
    15701570                r_vci_rsp_fsm = RSP_IDLE;
    15711571                r_icache_unc_req = false;
    1572                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
     1572                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_ins_error = true;
    15731573                break;
    15741574
    … …  
    15871587                    r_vci_rsp_fsm = RSP_IDLE;
    15881588                }
    1589                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
     1589                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
    15901590                break;
    15911591
    … …  
    15981598                    r_dcache_write_req = false;
    15991599                }
    1600                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) m_iss.setWriteBerr();
     1600                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) m_iss.setWriteBerr();
    16011601                break;
    16021602
    … …  
    16101610                r_vci_rsp_fsm = RSP_IDLE;
    16111611                r_dcache_unc_req = false;
    1612                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
     1612                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
    16131613                break;
    16141614
    … …  
    16221622                r_vci_rsp_fsm = RSP_IDLE;
    16231623                r_dcache_sc_req = false;
    1624                 if ( p_vci_ini_rw.rerror.read() != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
     1624                if ( (p_vci_ini_rw.rerror.read()&0x1) != vci_param::ERR_NORMAL ) r_vci_rsp_data_error = true;
    16251625                break;
    16261626
    … …  
    16311631                assert( p_vci_ini_c.reop.read() &&
    16321632                        "illegal VCI response packet for icache cleanup");
    1633                 assert( (p_vci_ini_c.rerror.read() == vci_param::ERR_NORMAL) &&
     1633                assert( ((p_vci_ini_c.rerror.read()&0x1) == vci_param::ERR_NORMAL) &&
    16341634                        "error in response packet for icache cleanup");
    16351635                if ( r_vci_rsp_fsm == RSP_INS_CLEANUP ) r_icache_cleanup_req = false;
    … …  
    20112011                p_vci_tgt.rtrdid  = r_tgt_trdid.read();
    20122012                p_vci_tgt.rdata   = 0;
    2013                 p_vci_tgt.rerror  = 0;
     2013                p_vci_tgt.rerror  = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    20142014                p_vci_tgt.reop    = true;
    20152015                break;
    … …  
    20222022                p_vci_tgt.rtrdid  = r_tgt_trdid.read();
    20232023                p_vci_tgt.rdata   = 0;
    2024                 p_vci_tgt.rerror  = 0;
     2024                p_vci_tgt.rerror  = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    20252025                p_vci_tgt.reop    = true;
    20262026                break;
    … …  
    20332033                p_vci_tgt.rtrdid  = r_tgt_trdid.read();
    20342034                p_vci_tgt.rdata   = 0;
    2035                 p_vci_tgt.rerror  = 0;
     2035                p_vci_tgt.rerror  = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    20362036                p_vci_tgt.reop    = true;
    20372037                break;

  • trunk/modules/vci_mem_cache_v2/caba/source/include/vci_mem_cache_v2.h

    r2 r82  
    334334      const soclib::common::AddressMaskingTable<vci_addr_t>   m_nline;
    335335
     336      // broadcast address
     337      vci_addr_t broadcast_addr;
     338
    336339      //////////////////////////////////////////////////
    337340      // Others registers
    … …  
    448451      sc_signal<copy_t>    r_write_to_init_cmd_d_copies;    // bit_vector of L1 to update
    449452      sc_signal<data_t>   *r_write_to_init_cmd_data;        // data (one cache line)
    450       sc_signal<bool>     *r_write_to_init_cmd_we;              // word enable
     453      sc_signal<be_t>     *r_write_to_init_cmd_be;              // word enable
    451454      sc_signal<size_t>    r_write_to_init_cmd_count;       // number of words in line
    452455      sc_signal<size_t>    r_write_to_init_cmd_index;       // index of first word in line

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

    r59 r82  
    3434//#define DEBUG_VCI_MEM_CACHE 1
    3535#define RANDOMIZE_SC
     36#define DEBUG_START_CYCLE 33069000
    3637
    3738namespace soclib { namespace caba {
    … …  
    295296
    296297
     298      // Set the broadcast address with Xmin,Xmax,Ymin,Ymax set to maximum
     299      broadcast_addr = 0x3 | (0x7C1F << (vci_param::N-20));
     300
    297301      // Get the segments associated to the MemCache
    298302      std::list<soclib::common::Segment>::iterator seg;
    … …  
    348352      r_write_be                                = new sc_signal<be_t>[nwords];
    349353      r_write_to_init_cmd_data          = new sc_signal<data_t>[nwords];
    350       r_write_to_init_cmd_we            = new sc_signal<bool>[nwords];
     354      r_write_to_init_cmd_be            = new sc_signal<be_t>[nwords];
    351355      r_write_to_ixr_cmd_data       = new sc_signal<data_t>[nwords];
    352356
    … …  
    530534
    531535#if DEBUG_VCI_MEM_CACHE
     536if(m_cpt_cycles > DEBUG_START_CYCLE){
    532537    std::cout << "---------------------------------------------" << std::dec << std::endl;
    533538    std::cout << "MEM_CACHE " << m_srcid_ini << " ; Time = " << m_cpt_cycles << std::endl
    … …  
    546551      << " - ALLOC_TRT FSM = " << alloc_trt_fsm_str[r_alloc_trt_fsm] << std::endl
    547552      << " - ALLOC_UPT FSM = " << alloc_upt_fsm_str[r_alloc_upt_fsm] << std::endl;
     553}
    548554#endif
    549555
    … …  
    700706            bool valid  = m_update_tab.decrement(r_init_rsp_upt_index.read(), count);
    701707#ifdef IDEBUG
     708if(m_cpt_cycles > DEBUG_START_CYCLE){
    702709        std::cout << sc_time_stamp() << " " << name() << " INIT_RSP_UPT_LOCK update table : " << std::endl;
    703710        m_update_tab.print();
     711}
    704712#endif
    705713            assert ( valid
    … …  
    724732            m_update_tab.clear(r_init_rsp_upt_index.read());
    725733#ifdef IDEBUG
     734if(m_cpt_cycles > DEBUG_START_CYCLE){
    726735        std::cout << sc_time_stamp() << " " << name() << " INIT_RSP_UPT_CLEAR update table : " << std::endl;
    727736        m_update_tab.print();
     737}
    728738#endif
    729739          }
    … …  
    777787            DirectoryEntry entry = m_cache_directory.read(m_cmd_read_addr_fifo.read(), way);
    778788#ifdef DDEBUG
     789if(m_cpt_cycles > DEBUG_START_CYCLE){
    779790           std::cout << "In READ_DIR_LOCK printing the entry of address is : " << std::hex << m_cmd_read_addr_fifo.read() << std::endl;
    780791           entry.print();
    781792           std::cout << "done" << std::endl;
     793}
    782794#endif
    783795
    … …  
    832844              }
    833845              if(!inst_read && !is_cnt){ // Data read, vector mode
    834                 assert(!(r_read_d_copies.read() & (0x1 << m_cmd_read_srcid_fifo.read())) && "MemCache Error : processor read on an already owned cache line");
     846                if(r_read_d_copies.read() & (0x1 << m_cmd_read_srcid_fifo.read())) {
     847                    std::cout << "MemCache Error : processor read on an already owned cache line, Time : " << m_cpt_cycles << std::endl;
     848                    exit(0);
     849                }
    835850                entry.d_copies  = r_read_d_copies.read() | (0x1 << m_cmd_read_srcid_fifo.read());
    836851                entry.i_copies  = r_read_i_copies.read();
    … …  
    848863            }
    849864#ifdef DDEBUG
     865if(m_cpt_cycles > DEBUG_START_CYCLE){
    850866           std::cout << "In READ_DIR_HIT printing the entry of address is : " << std::endl;
    851867           entry.print();
    852868           std::cout << "done" << std::endl;
     869}
    853870#endif
    854871
    … …  
    881898          if ( r_alloc_trt_fsm.read() == ALLOC_TRT_READ ) {
    882899#ifdef TDEBUG
     900if(m_cpt_cycles > DEBUG_START_CYCLE){
    883901        std::cout << sc_time_stamp() << " " << name() << " READ_TRT_LOCK " << std::endl;
     902}
    884903#endif
    885904            size_t index = 0;
    … …  
    912931                std::vector<data_t>(m_words,0));
    913932#ifdef TDEBUG
     933if(m_cpt_cycles > DEBUG_START_CYCLE){
    914934        std::cout << sc_time_stamp() << " " << name() << " READ_TRT_SET transaction table : " << std::endl;
    915935        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    916936          m_transaction_tab.print(i);
     937}
    917938#endif
    918939
    … …  
    11781199                index);
    11791200#ifdef IDEBUG
     1201if(m_cpt_cycles > DEBUG_START_CYCLE){
    11801202            if(wok){
    11811203        std::cout << sc_time_stamp() << " " << name() << " WRITE_UPT_LOCK update table : " << std::endl;
    11821204        m_update_tab.print();
    11831205            }
     1206}
    11841207#endif
    11851208            r_write_upt_index = index;
    … …  
    12101233
    12111234            for(size_t i=0; i<m_words ; i++){
    1212               if(r_write_be[i].read())  r_write_to_init_cmd_we[i]=true;
    1213               else                      r_write_to_init_cmd_we[i]=false;
     1235              r_write_to_init_cmd_be[i]=r_write_be[i].read();
    12141236            }
    12151237
    … …  
    12411263          if ( r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE ) {
    12421264#ifdef TDEBUG
     1265if(m_cpt_cycles > DEBUG_START_CYCLE){
    12431266        std::cout << sc_time_stamp() << " " << name() << " READ_TRT_LOCK " << std::endl;
     1267}
    12441268#endif
    12451269            size_t hit_index = 0;
    … …  
    12921316                data_vector);
    12931317#ifdef TDEBUG
     1318if(m_cpt_cycles > DEBUG_START_CYCLE){
    12941319        std::cout << sc_time_stamp() << " " << name() << " WRITE_TRT_SET transaction table : " << std::endl;
    12951320        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    12961321          m_transaction_tab.print(i);
     1322}
    12971323#endif
    12981324
    … …  
    13181344            r_write_fsm = WRITE_RSP;
    13191345#ifdef TDEBUG
     1346if(m_cpt_cycles > DEBUG_START_CYCLE){
    13201347        std::cout << sc_time_stamp() << " " << name() << " WRITE_TRT_DATA transaction table : " << std::endl;
    13211348        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    13221349          m_transaction_tab.print(i);
     1350}
    13231351#endif
    13241352
    … …  
    13771405                index);
    13781406#ifdef IDEBUG
     1407if(m_cpt_cycles > DEBUG_START_CYCLE){
    13791408            if(wok){
    13801409        std::cout << sc_time_stamp() << " " << name() << " WRITE_INVAL_LOCK update table : " << std::endl;
    13811410        m_update_tab.print();
    13821411            }
     1412}
    13831413#endif
    13841414            r_write_upt_index = index;
    … …  
    14081438                std::vector<data_t>(m_words,0));
    14091439#ifdef TDEBUG
     1440if(m_cpt_cycles > DEBUG_START_CYCLE){
    14101441        std::cout << sc_time_stamp() << " " << name() << " WRITE_DIR_INVAL transaction table : " << std::endl;
    14111442        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    14121443          m_transaction_tab.print(i);
     1444}
    14131445#endif
    14141446
    … …  
    14471479
    14481480            for(size_t i=0; i<m_words ; i++){
    1449               r_write_to_init_cmd_we[i]=false;
     1481              r_write_to_init_cmd_be[i]=0;
    14501482              r_write_to_init_cmd_data[i] = 0;
    14511483            }
    … …  
    16171649            r_ixr_rsp_fsm = IXR_RSP_IDLE;
    16181650#ifdef TDEBUG
     1651if(m_cpt_cycles > DEBUG_START_CYCLE){
    16191652        std::cout << sc_time_stamp() << " " << name() << " IXR_RSP_TRT_ERASE transaction table : " << std::endl;
    16201653        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    16211654          m_transaction_tab.print(i);
     1655}
    16221656#endif
    16231657
    … …  
    16381672            if ( eop ) {
    16391673#ifdef TDEBUG
     1674if(m_cpt_cycles > DEBUG_START_CYCLE){
    16401675        std::cout << sc_time_stamp() << " " << name() << " IXR_RSP_TRT_READ transaction table : " << std::endl;
    16411676        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    16421677          m_transaction_tab.print(i);
     1678}
    16431679#endif
    16441680
    … …  
    16871723              break;
    16881724#ifdef TDEBUG
     1725if(m_cpt_cycles > DEBUG_START_CYCLE){
    16891726        std::cout << "XRAM_RSP FSM in XRAM_RSP_IDLE state" << std::endl;
     1727}
    16901728#endif
    16911729            }
    … …  
    16991737            r_xram_rsp_fsm           = XRAM_RSP_TRT_COPY;
    17001738#ifdef TDEBUG
     1739if(m_cpt_cycles > DEBUG_START_CYCLE){
    17011740        std::cout << "XRAM_RSP FSM in XRAM_RSP_DIR_LOCK state" << std::endl;
     1741}
    17021742#endif
    17031743          }
    … …  
    17341774            r_xram_rsp_fsm = XRAM_RSP_INVAL_LOCK;
    17351775#ifdef TDEBUG
     1776if(m_cpt_cycles > DEBUG_START_CYCLE){
    17361777        std::cout << "XRAM_RSP FSM in XRAM_RSP_TRT_COPY state" << std::endl;
    17371778        std::cout << "Victim way : " << std::hex << way << " set " << std::hex << set << std::endl;
    17381779        victim.print();
     1780}
    17391781#endif
    17401782          }
    … …  
    17461788          if ( r_alloc_upt_fsm == ALLOC_UPT_XRAM_RSP ) {
    17471789#ifdef IDEBUG
     1790if(m_cpt_cycles > DEBUG_START_CYCLE){
    17481791        std::cout << "XRAM_RSP FSM in XRAM_RSP_INVAL_LOCK state" << std::endl;
     1792}
    17491793#endif
    17501794            size_t index;
    … …  
    17521796              r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    17531797#ifdef IDEBUG
     1798if(m_cpt_cycles > DEBUG_START_CYCLE){
    17541799        std::cout << "XRAM_RSP FSM in XRAM_RSP_INVAL_LOCK state to XRAM_RSP_INVAL_WAIT state" << std::endl;
     1800}
    17551801#endif
    17561802
    … …  
    17591805              r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    17601806#ifdef IDEBUG
     1807if(m_cpt_cycles > DEBUG_START_CYCLE){
    17611808        std::cout << "XRAM_RSP FSM in XRAM_RSP_INVAL_LOCK state to XRAM_RSP_INVAL_WAIT state" << std::endl;
     1809}
    17621810#endif
    17631811            }
    … …  
    17651813              r_xram_rsp_fsm = XRAM_RSP_DIR_UPDT;
    17661814#ifdef IDEBUG
     1815if(m_cpt_cycles > DEBUG_START_CYCLE){
    17671816        std::cout << "XRAM_RSP FSM in XRAM_RSP_INVAL_LOCK state to XRAM_RSP_DIR_UPDT state" << std::endl;
     1817}
    17681818#endif
    17691819            }
    … …  
    17771827          break;
    17781828#ifdef IDEBUG
     1829if(m_cpt_cycles > DEBUG_START_CYCLE){
    17791830        std::cout << "XRAM_RSP FSM in XRAM_RSP_INVAL_WAIT state" << std::endl;
     1831}
    17801832#endif
    17811833        }
    … …  
    18221874          m_cache_directory.write(set, way, entry);
    18231875#ifdef DDEBUG
     1876if(m_cpt_cycles > DEBUG_START_CYCLE){
    18241877           std::cout << "printing the entry : " << std::endl;
    18251878           entry.print();
    18261879           std::cout << "done" << std::endl;
     1880}
    18271881#endif
    18281882
    18291883#ifdef TDEBUG
     1884if(m_cpt_cycles > DEBUG_START_CYCLE){
    18301885        std::cout << sc_time_stamp() << " " << name() << " XRAM_RSP_DIR_UPDT transaction table : " << std::endl;
    18311886        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    18321887          m_transaction_tab.print(i);
     1888}
    18331889#endif
    18341890
    … …  
    18491905
    18501906#ifdef IDEBUG
     1907if(m_cpt_cycles > DEBUG_START_CYCLE){
    18511908            std::cout << "xram_rsp : record invalidation, time = " << std::dec << m_cpt_cycles << std::endl;
    18521909            m_update_tab.print();
     1910}
    18531911#endif
    18541912            r_xram_rsp_upt_index = index;
    … …  
    18851943                std::vector<data_t>(m_words,0) );
    18861944#ifdef TDEBUG
     1945if(m_cpt_cycles > DEBUG_START_CYCLE){
    18871946        std::cout << sc_time_stamp() << " " << name() << " XRAM_RSP_TRT_DIRTY transaction table : " << std::endl;
    18881947        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    18891948          m_transaction_tab.print(i);
     1949}
    18901950#endif
    18911951
    … …  
    19151975
    19161976#ifdef DDEBUG
     1977if(m_cpt_cycles > DEBUG_START_CYCLE){
    19171978        std::cout << "XRAM_RSP FSM in XRAM_RSP_DIR_RSP state" << std::endl;
     1979}
    19181980#endif
    19191981          }
    … …  
    19331995            else                                    r_xram_rsp_fsm = XRAM_RSP_IDLE;
    19341996#ifdef DDEBUG
     1997if(m_cpt_cycles > DEBUG_START_CYCLE){
    19351998        std::cout << "XRAM_RSP FSM in XRAM_RSP_INVAL state" << std::endl;
     1999}
    19362000#endif
    19372001          }
    … …  
    19512015            r_xram_rsp_fsm = XRAM_RSP_IDLE;
    19522016#ifdef TDEBUG
     2017if(m_cpt_cycles > DEBUG_START_CYCLE){
    19532018        std::cout << "XRAM_RSP FSM in XRAM_RSP_WRITE_DIRTY state" << std::endl;
     2019}
    19542020#endif
    19552021          }
    … …  
    19812047            }
    19822048            if ( (p_vci_tgt_cleanup.cmd.read() == vci_param::CMD_WRITE) &&
    1983                 (((addr_t)(p_vci_tgt_cleanup.address.read())) != BROADCAST_ADDR) &&
     2049                (((addr_t)(p_vci_tgt_cleanup.address.read())&0x3) != 0x3) &&
    19842050                reached) {
    19852051
    … …  
    20062072           DirectoryEntry entry = m_cache_directory.read(cleanup_address , way);
    20072073#ifdef DDEBUG
     2074if(m_cpt_cycles > DEBUG_START_CYCLE){
    20082075           std::cout << "In CLEANUP_DIR_LOCK printing the entry of address is : " << std::hex << cleanup_address << std::endl;
    20092076           entry.print();
    20102077           std::cout << "done" << std::endl;
     2078}
    20112079#endif
    20122080            r_cleanup_is_cnt    = entry.is_cnt;
    … …  
    20892157            if(!hit_inval) {
    20902158#ifdef DEBUG_VCI_MEM_CACHE
     2159if(m_cpt_cycles > DEBUG_START_CYCLE){
    20912160              std::cout << "MEM_CACHE WARNING: cleanup with no corresponding entry at address : " << std::hex << (r_cleanup_nline.read()*4*m_words) << std::dec << std::endl;
     2161}
    20922162#endif
    20932163              r_cleanup_fsm = CLEANUP_RSP;
    … …  
    21112181            m_update_tab.clear(r_cleanup_index.read());
    21122182#ifdef IDEBUG
     2183if(m_cpt_cycles > DEBUG_START_CYCLE){
    21132184        std::cout << sc_time_stamp() << " " << name() << " CLEANUP_UPT_WRITE update table : " << std::endl;
    21142185        m_update_tab.print();
     2186}
    21152187#endif
    21162188
    … …  
    22062278            // set Atomic Table
    22072279            m_atomic_tab.set(m_cmd_llsc_srcid_fifo.read(), m_cmd_llsc_addr_fifo.read());
     2280
     2281#ifdef DDEBUG
     2282if(m_cpt_cycles > DEBUG_START_CYCLE){
     2283           std::cout << "In LLSC_DIR_LOCK printing the entry of address is : " << std::hex << m_cmd_llsc_addr_fifo.read() << std::endl;
     2284           entry.print();
     2285           std::cout << "done" << std::endl;
     2286}
     2287#endif
     2288
    22082289
    22092290            if ( entry.valid )  r_llsc_fsm = LL_DIR_HIT;
    … …  
    23472428                index);
    23482429#ifdef IDEBUG
     2430if(m_cpt_cycles > DEBUG_START_CYCLE){
    23492431            if(wok){
    23502432        std::cout << sc_time_stamp() << " " << name() << " SC_UPT_LOCK update table : " << std::endl;
    23512433        m_update_tab.print();
    23522434            }
     2435}
    23532436#endif
    23542437            r_llsc_upt_index = index;
    … …  
    24362519                index);
    24372520#ifdef IDEBUG
     2521if(m_cpt_cycles > DEBUG_START_CYCLE){
    24382522            if(wok){
    24392523        std::cout << sc_time_stamp() << " " << name() << " LLSC_INVAL_LOCK update table : " << std::endl;
    24402524        m_update_tab.print();
    24412525            }
     2526}
    24422527#endif
    24432528            r_llsc_upt_index = index;
    … …  
    24662551                std::vector<data_t>(m_words,0));
    24672552#ifdef TDEBUG
     2553if(m_cpt_cycles > DEBUG_START_CYCLE){
    24682554        std::cout << sc_time_stamp() << " " << name() << " SC_DIR_INVAL transaction table : " << std::endl;
    24692555        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    24702556          m_transaction_tab.print(i);
     2557}
    24712558#endif
    24722559            // reset Atomic Table
    … …  
    26242711            }
    26252712#ifdef TDEBUG
     2713if(m_cpt_cycles > DEBUG_START_CYCLE){
    26262714        std::cout << sc_time_stamp() << " " << name() << " LLSC_TRT_SET transaction table : " << std::endl;
    26272715        for(size_t i = 0 ; i < m_transaction_tab.size() ; i++)
    26282716          m_transaction_tab.print(i);
     2717}
    26292718#endif
    26302719
    … …  
    36113700        p_vci_tgt.rtrdid   = r_write_to_tgt_rsp_trdid.read();
    36123701        p_vci_tgt.rpktid   = r_write_to_tgt_rsp_pktid.read();
    3613         p_vci_tgt.rerror   = 0;
     3702        p_vci_tgt.rerror   = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    36143703        p_vci_tgt.reop     = true;
    36153704        break;
    … …  
    36843773        p_vci_ini.cmdval  = true;
    36853774        if(r_xram_rsp_to_init_cmd_brdcast.read())
    3686           p_vci_ini.address = BROADCAST_ADDR;
     3775          p_vci_ini.address = broadcast_addr;
    36873776        else {
    36883777          if(r_init_cmd_inst.read()) {
    … …  
    37003789      case INIT_CMD_BRDCAST:
    37013790        p_vci_ini.cmdval  = true;
    3702         p_vci_ini.address = BROADCAST_ADDR;
     3791        p_vci_ini.address = broadcast_addr;
    37033792        p_vci_ini.wdata   = (addr_t)r_write_to_init_cmd_nline.read();
    37043793        p_vci_ini.be      = ((r_write_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    37303819        p_vci_ini.wdata   = r_write_to_init_cmd_data[r_init_cmd_cpt.read() +
    37313820          r_write_to_init_cmd_index.read()].read();
    3732         if(r_write_to_init_cmd_we[r_init_cmd_cpt.read() +
    3733             r_write_to_init_cmd_index.read()].read()) 
    3734           p_vci_ini.be      = 0xF;
    3735         else                    p_vci_ini.be      = 0x0;
     3821        p_vci_ini.be      = r_write_to_init_cmd_be[r_init_cmd_cpt.read() +r_write_to_init_cmd_index.read()].read() ; 
    37363822        p_vci_ini.plen    = 4 * (r_write_to_init_cmd_count.read() + 2);
    37373823        p_vci_ini.trdid   = r_write_to_init_cmd_trdid.read();
    … …  
    37413827      case INIT_CMD_SC_BRDCAST:
    37423828        p_vci_ini.cmdval  = true;
    3743         p_vci_ini.address = BROADCAST_ADDR;
     3829        p_vci_ini.address = broadcast_addr;
    37443830        p_vci_ini.wdata   = (addr_t)r_llsc_to_init_cmd_nline.read();
    37453831        p_vci_ini.be      = ((r_llsc_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    38103896          p_vci_tgt_cleanup.rpktid = r_cleanup_pktid.read();
    38113897          p_vci_tgt_cleanup.rtrdid = r_cleanup_trdid.read();
    3812           p_vci_tgt_cleanup.rerror = 0;
     3898          p_vci_tgt_cleanup.rerror = 0x2 & ( (1 << (vci_param::E + 1)) - 1);
    38133899          p_vci_tgt_cleanup.reop   = 1;
    38143900          break;

  • trunk/modules/vci_mem_cache_v3/caba/source/include/vci_mem_cache_v3.h

    r2 r82  
    6161#define TRANSACTION_TAB_LINES 4     // Number of lines in the transaction tab
    6262#define UPDATE_TAB_LINES 4          // Number of lines in the update tab
    63 #define BROADCAST_ADDR 0x0000000003 // Address to send the broadcast invalidate
    6463
    6564namespace soclib {  namespace caba {
    … …  
    362361      const soclib::common::AddressMaskingTable<vci_addr_t>   m_nline;
    363362
     363      // broadcast address
     364      vci_addr_t broadcast_addr;
     365
    364366      //////////////////////////////////////////////////
    365367      // Others registers

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

    r57 r82  
    325325      assert(nways <= 32);
    326326
     327      // Set the broadcast address with Xmin,Xmax,Ymin,Ymax set to maximum
     328      broadcast_addr = 0x3 | (0x7C1F << (vci_param::N-20));
    327329
    328330      // Get the segments associated to the MemCache
    … …  
    23582360            }
    23592361            if ( (p_vci_tgt_cleanup.cmd.read() == vci_param::CMD_WRITE) &&
    2360                 (((addr_t)(p_vci_tgt_cleanup.address.read())) != BROADCAST_ADDR) &&
     2362                (((addr_t)(p_vci_tgt_cleanup.address.read())&0x3) != 0x3) &&
    23612363                reached) {
    23622364
    … …  
    43374339        p_vci_tgt.rtrdid   = r_write_to_tgt_rsp_trdid.read();
    43384340        p_vci_tgt.rpktid   = r_write_to_tgt_rsp_pktid.read();
    4339         p_vci_tgt.rerror   = 0;
     4341        p_vci_tgt.rerror   = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    43404342        p_vci_tgt.reop     = true;
    43414343        break;
    … …  
    44214423      case INIT_CMD_XRAM_BRDCAST:
    44224424        p_vci_ini.cmdval  = true;
    4423         p_vci_ini.address = BROADCAST_ADDR;
     4425        p_vci_ini.address = broadcast_addr;
    44244426        p_vci_ini.wdata   = (uint32_t)r_xram_rsp_to_init_cmd_nline.read();
    44254427        p_vci_ini.be      = ((r_xram_rsp_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    44314433      case INIT_CMD_WRITE_BRDCAST:
    44324434        p_vci_ini.cmdval  = true;
    4433         p_vci_ini.address = BROADCAST_ADDR;
     4435        p_vci_ini.address = broadcast_addr;
    44344436        p_vci_ini.wdata   = (addr_t)r_write_to_init_cmd_nline.read();
    44354437        p_vci_ini.be      = ((r_write_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    44764478      case INIT_CMD_SC_BRDCAST:
    44774479        p_vci_ini.cmdval  = true;
    4478         p_vci_ini.address = BROADCAST_ADDR;
     4480        p_vci_ini.address = broadcast_addr;
    44794481        p_vci_ini.wdata   = (addr_t)r_llsc_to_init_cmd_nline.read();
    44804482        p_vci_ini.be      = ((r_llsc_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    45494551          p_vci_tgt_cleanup.rpktid = r_cleanup_pktid.read();
    45504552          p_vci_tgt_cleanup.rtrdid = r_cleanup_trdid.read();
    4551           p_vci_tgt_cleanup.rerror = 0;
     4553          p_vci_tgt_cleanup.rerror = 0x2 & ( (1 << (vci_param::E + 1)) - 1);
    45524554          p_vci_tgt_cleanup.reop   = 1;
    45534555          break;

  • trunk/modules/vci_mem_cache_v4/caba/source/include/vci_mem_cache_v4.h

    r2 r82  
    354354      const soclib::common::AddressMaskingTable<vci_addr_t>   m_nline;
    355355
     356      // broadcast address
     357      vci_addr_t broadcast_addr;
     358
    356359      //////////////////////////////////////////////////
    357360      // Others registers

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

    r57 r82  
    321321      assert(nways <= 32);
    322322
     323      // Set the broadcast address with Xmin,Xmax,Ymin,Ymax set to maximum
     324      broadcast_addr = 0x3 | (0x7C1F << (vci_param::N-20));
    323325
    324326      // Get the segments associated to the MemCache
    … …  
    23242326            }
    23252327            if ( (p_vci_tgt_cleanup.cmd.read() == vci_param::CMD_WRITE) &&
    2326                 (((addr_t)(p_vci_tgt_cleanup.address.read())) != BROADCAST_ADDR) &&
     2328                (((addr_t)(p_vci_tgt_cleanup.address.read())&0x3) != 0x3) &&
    23272329                reached) {
    23282330
    … …  
    42474249        p_vci_tgt.rtrdid   = r_write_to_tgt_rsp_trdid.read();
    42484250        p_vci_tgt.rpktid   = r_write_to_tgt_rsp_pktid.read();
    4249         p_vci_tgt.rerror   = 0;
     4251        p_vci_tgt.rerror   = 0x2 & ( (1 << (vci_param::E + 1)) - 1); // Write OK
    42504252        p_vci_tgt.reop     = true;
    42514253        break;
    … …  
    42564258        p_vci_tgt.rtrdid   = r_cleanup_to_tgt_rsp_trdid.read();
    42574259        p_vci_tgt.rpktid   = r_cleanup_to_tgt_rsp_pktid.read();
    4258         p_vci_tgt.rerror   = 0;
     4260        p_vci_tgt.rerror   = 0; // Can be a SC rsp
    42594261        p_vci_tgt.reop     = true;
    42604262        break;
    … …  
    42834285        p_vci_tgt.rtrdid   = r_init_rsp_to_tgt_rsp_trdid.read();
    42844286        p_vci_tgt.rpktid   = r_init_rsp_to_tgt_rsp_pktid.read();
    4285         p_vci_tgt.rerror   = 0;
     4287        p_vci_tgt.rerror   = 0; // Can be a SC rsp
    42864288        p_vci_tgt.reop     = true;     
    42874289        break;
    … …  
    43314333      case INIT_CMD_XRAM_BRDCAST:
    43324334        p_vci_ini.cmdval  = true;
    4333         p_vci_ini.address = BROADCAST_ADDR;
     4335        p_vci_ini.address = broadcast_addr;
    43344336        p_vci_ini.wdata   = (uint32_t)r_xram_rsp_to_init_cmd_nline.read();
    43354337        p_vci_ini.be      = ((r_xram_rsp_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    43414343      case INIT_CMD_WRITE_BRDCAST:
    43424344        p_vci_ini.cmdval  = true;
    4343         p_vci_ini.address = BROADCAST_ADDR;
     4345        p_vci_ini.address = broadcast_addr;
    43444346        p_vci_ini.wdata   = (addr_t)r_write_to_init_cmd_nline.read();
    43454347        p_vci_ini.be      = ((r_write_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    43964398      case INIT_CMD_SC_BRDCAST:
    43974399        p_vci_ini.cmdval  = true;
    4398         p_vci_ini.address = BROADCAST_ADDR;
     4400        p_vci_ini.address = broadcast_addr;
    43994401        p_vci_ini.wdata   = (addr_t)r_llsc_to_init_cmd_nline.read();
    44004402        p_vci_ini.be      = ((r_llsc_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    45074509          p_vci_tgt_cleanup.rpktid = r_cleanup_pktid.read();
    45084510          p_vci_tgt_cleanup.rtrdid = r_cleanup_trdid.read();
    4509           p_vci_tgt_cleanup.rerror = 0;
     4511          p_vci_tgt_cleanup.rerror = 0x2 & ( (1 << (vci_param::E + 1)) - 1);
    45104512          p_vci_tgt_cleanup.reop   = 1;
    45114513          break;
Note: See TracChangeset for help on using the changeset viewer.