Changeset 477


Ignore:
Timestamp:
Jul 26, 2013, 5:03:12 PM (9 years ago)
Author:
lgarcia
Message:

Reintroducing RWT branch merging the last modifications of the
trunk (CLACK channel)
WARNING: bugs remaining (with 1c16p and small caches (L2:16*16; L1:4*4))

Location:
branches/RWT
Files:
4 added
8 edited
5 copied

Legend:

Unmodified
Added
Removed
  • branches/RWT/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h

    r468 r477  
    4141 *
    4242 * flit 1
    43  * ----------------------------------------------------------------------------------------------
    44  * EOP:0 |    DEST    |   SRCID   | NLINE MSB(2 bits)| X | WAY_INDEX(2 bits) | TYPE:0b1X | BC:0
    45  *       |  (10 bits) | (14 bits) |                  |   |                   |           |
    46  * ----------------------------------------------------------------------------------------------
     43 * --------------------------------------------------------------------------------------------------------
     44 * EOP:0 |    DEST    |   SRCID   | NLINE MSB(2 bits)| CONTAINS_DATA | WAY_INDEX(2 bits) | TYPE:0b1X | BC:0
     45 *       |  (10 bits) | (14 bits) |                  |               |                   |           |
     46 * --------------------------------------------------------------------------------------------------------
    4747 *                                                                                 | X: 0 DATA  |
    4848 *                                                                                 |    1 INST  |
    4949 * flit 2
    5050 * ----------------------------------------------------------------------------------------------
    51  * EOP:1 |                                                                         NLINE(32 bits)
     51 * EOP:0/1 |                                                                       NLINE(32 bits)
     52 * ----------------------------------------------------------------------------------------------
     53 *
     54 * flit N for data
     55 * ----------------------------------------------------------------------------------------------
     56 * EOP:0/1 |                                                                       WDATA(32 bits)
    5257 * ----------------------------------------------------------------------------------------------
    5358 *
     
    175180    static const uint8_t  CLEANUP_NLINE_LSB_SHIFT      = 0;
    176181    static const uint64_t CLEANUP_NLINE_LSB_MASK       = ((1ULL<<32)-1);
     182    static const uint8_t  CLEANUP_DATA_UPDT_SHIFT      = 0;
     183    static const uint64_t CLEANUP_DATA_UPDT_MASK       = ((1ULL<<32)-1);
     184    static const uint8_t  CLEANUP_NCC_SHIFT  = 5;
     185    static const uint64_t CLEANUP_NCC_MASK   = 1;
    177186
    178187    static const uint8_t  MULTI_ACK_DEST_SHIFT         = CLEANUP_DEST_SHIFT;
     
    277286      CLEANUP_WAY_INDEX,
    278287      CLEANUP_NLINE_LSB,
     288      CLEANUP_DATA_UPDT,
     289      CLEANUP_NCC,
    279290
    280291      MULTI_ACK_DEST,
     
    321332        GET_FIELD(flit,CLEANUP_WAY_INDEX);
    322333        GET_FIELD(flit,CLEANUP_NLINE_LSB);
     334        GET_FIELD(flit,CLEANUP_DATA_UPDT);
     335        GET_FIELD(flit,CLEANUP_NCC);
    323336        GET_FIELD(flit,MULTI_ACK_DEST);
    324337        GET_FIELD(flit,MULTI_ACK_UPDT_INDEX);
     
    361374        SET_FIELD(flit,value,CLEANUP_WAY_INDEX);
    362375        SET_FIELD(flit,value,CLEANUP_NLINE_LSB);
     376        SET_FIELD(flit,value,CLEANUP_DATA_UPDT);
     377        SET_FIELD(flit,value,CLEANUP_NCC);
    363378        SET_FIELD(flit,value,MULTI_ACK_DEST);
    364379        SET_FIELD(flit,value,MULTI_ACK_UPDT_INDEX);
  • branches/RWT/lib/generic_cache_tsar/include/generic_cache.h

    r393 r477  
    7676{
    7777    CACHE_SLOT_STATE_EMPTY,
    78     CACHE_SLOT_STATE_VALID,
     78    CACHE_SLOT_STATE_VALID_CC,
    7979    CACHE_SLOT_STATE_ZOMBI,
     80    CACHE_SLOT_STATE_VALID_NCC,
    8081};
    8182
     
    118119        return r_lru[(way*m_sets)+set];
    119120    }
    120 
     121   
    121122    //////////////////////////////////////////////
    122123    inline int &cache_state(size_t way, size_t set)
     
    125126    }
    126127
     128   
    127129    /////////////////////////////////////////////////
    128130    inline void cache_set_lru(size_t way, size_t set)
     
    218220    }
    219221
     222    inline int get_cache_state(int way, int set)
     223    {
     224        return cache_state(way,set);
     225    }
     226   
    220227    /////////////////////////////////////////////////////////////////////
    221228    // Read a single 32 bits word.
     
    233240        {
    234241            if ( (tag == cache_tag(way, set)) 
    235                    && (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     242                   && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)) )
    236243            {
    237244                *dt = cache_data(way, set, word);
     
    262269        {
    263270            if ( (tag == cache_tag(way, set)) and
    264                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     271                 ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)))
    265272            {
    266273                *selway  = way;
     
    308315            {
    309316
    310                 if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID )
     317                if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC )
    311318                {
    312                     *state   = CACHE_SLOT_STATE_VALID;
     319                    *state   = CACHE_SLOT_STATE_VALID_CC;
     320                    *selway  = way;
     321                    *selset  = set;
     322                    *selword = word;
     323                    *dt      = cache_data(way, set, word);
     324                    cache_set_lru(way, set);
     325                }
     326                else if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC )
     327                {
     328                    *state   = CACHE_SLOT_STATE_VALID_NCC;
    313329                    *selway  = way;
    314330                    *selset  = set;
     
    347363        {
    348364            if ( (tag == cache_tag(way, set)) 
    349                    && (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     365                   && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ) )
    350366            {
    351367                *selway  = way;
     
    382398        {
    383399            if ( (tag == cache_tag(way, set))   
    384                    && (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     400                   &&( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) )
    385401            {
    386402                *dt      = cache_data(way, set, word);
     
    433449            {
    434450
    435                 if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID )
     451                if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC )
    436452                {
    437                     *state   = CACHE_SLOT_STATE_VALID;
     453                    *state   = CACHE_SLOT_STATE_VALID_CC;
    438454                    *selway  = way;
    439455                    *selset  = set;
     
    446462                    cache_set_lru(way, set);
    447463                }
     464
     465                else if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC )
     466                {
     467                    *state   = CACHE_SLOT_STATE_VALID_NCC;
     468                    *selway  = way;
     469                    *selset  = set;
     470                    *selword = word;
     471                    *dt      = cache_data(way, set, word);
     472                    if ( word+1 < m_words)
     473                    {
     474                        *dt_next = cache_data(way, set, word+1);
     475                    }
     476                    cache_set_lru(way, set);
     477                }
     478
    448479                else if ( cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI )
    449480                {
     
    477508        {
    478509            if ( (tag == cache_tag(way, set))
    479                    && (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     510                   && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or(cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ) )
    480511            {
    481512                *selway  = way;
     
    509540        const size_t      ad_set  = m_y[ad];
    510541        const size_t      ad_word = m_x[ad];
    511 
    512542        for ( size_t _way = 0; _way < m_ways; _way++ )
    513543        {
     
    556586                      data_t    data)
    557587    {
     588       /**/ //std::cout << "write cache : way = "<<way<<" | set = "<<set<<" | word = "<<word<<" | data = "<<(uint32_t)data << std::endl;
    558589        cache_data(way, set, word) = data;
    559590        cache_set_lru(way, set);
     
    584615                      addr_t*   nline)
    585616    {
    586         if ( cache_state(way,set) == CACHE_SLOT_STATE_VALID )
     617        if( (cache_state(way,set) == CACHE_SLOT_STATE_VALID_CC) or  (cache_state(way,set) == CACHE_SLOT_STATE_VALID_NCC))
    587618        {
    588619            cache_state(way,set) = CACHE_SLOT_STATE_EMPTY;
     
    615646        for ( size_t _way = 0 ; _way < m_ways && !found ; _way++ )
    616647        {
    617             if ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID )  // empty
     648            if( ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_CC ) and ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_NCC ))  // empty
    618649            {
    619650                found   = true;
     
    674705            }
    675706        }
     707        //////////////////////////////////////////////////////////////
     708        /*for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ )
     709        {
     710            if ( not cache_lru(_way, _set) and
     711                 (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) and
     712                 (cache_state(_way, _set) == CACHE_SLOT_STATE_VALID_NCC) )
     713            {
     714                *found   = true;
     715                *cleanup = true;
     716                *way     = _way;
     717                *set     = m_y[ad];
     718                *victim  = (addr_t)((cache_tag(*way,_set) * m_sets) + _set);
     719                return;
     720            }
     721        }*/
    676722        // Search first not zombi old slot
    677723        for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ )
     
    718764
    719765        cache_tag(way, set)   = tag;
    720         cache_state(way, set) = CACHE_SLOT_STATE_VALID;
     766        cache_state(way, set) = CACHE_SLOT_STATE_VALID_CC;
    721767        cache_set_lru(way, set);
    722768    }
     
    733779        addr_t  tag     = m_z[ad];
    734780
    735         assert( ( (state == CACHE_SLOT_STATE_VALID) or
     781        assert( ( (state == CACHE_SLOT_STATE_VALID_CC) or
     782                  (state == CACHE_SLOT_STATE_VALID_NCC) or
    736783                  (state == CACHE_SLOT_STATE_ZOMBI) or
    737784                  (state == CACHE_SLOT_STATE_EMPTY) ) and
     
    747794        cache_state(way, set) = state;
    748795
    749         if ( state == CACHE_SLOT_STATE_VALID ) cache_set_lru(way, set);
     796        if ( (state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC) ) cache_set_lru(way, set);
    750797    }
    751798
     
    759806                           int      state)
    760807    {
    761         assert( ( (state == CACHE_SLOT_STATE_VALID) or
     808        assert( ( (state == CACHE_SLOT_STATE_VALID_CC) or
     809                  (state == CACHE_SLOT_STATE_VALID_NCC) or
    762810                  (state == CACHE_SLOT_STATE_ZOMBI) or
    763811                  (state == CACHE_SLOT_STATE_EMPTY) ) and
     
    772820        cache_state(way, set) = state;
    773821
    774         if ( state == CACHE_SLOT_STATE_VALID ) cache_set_lru(way, set);
     822        if ( (state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC) ) cache_set_lru(way, set);
    775823    }
    776824
     
    788836
    789837        cache_tag(way, set)   = tag;
    790         cache_state(way, set) = CACHE_SLOT_STATE_VALID;
     838        cache_state(way, set) = CACHE_SLOT_STATE_VALID_CC;
    791839        cache_set_lru(way, set);
    792840        for ( size_t word = 0 ; word < m_words ; word++ )
     
    835883                    std::cout << " | " << cache_data(way,set,word) ;
    836884                }
    837                 std::cout << std::endl ;
     885                std::cout << std::dec << std::endl ;
    838886            }
    839887        }
     
    853901        {
    854902            if ( (tag == cache_tag(way, set)) and
    855                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     903                 (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    856904            {
    857905                hit                   = true;
     
    878926        {
    879927            if ( (tag == cache_tag(way, set)) and
    880                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     928                 (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    881929            {
    882930                hit                   = true;
     
    923971        {
    924972            if ( (tag == cache_tag(way, set)) and
    925                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     973                 (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    926974            {
    927975                cache_data(way, set, word) = dt;
     
    948996        {
    949997            if ( (tag == cache_tag(way, set)) and
    950                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     998                 (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    951999            {
    9521000                data_t mask = be2mask(be);
     
    9751023        {
    9761024            if ( (tag == cache_tag(way, set)) and
    977                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     1025                 (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    9781026            {
    9791027                cache_data(way, set, word) = dt;
     
    10021050        {
    10031051            if ( (tag == cache_tag(way, set)) and
    1004                  (cache_state(way, set) == CACHE_SLOT_STATE_VALID) )
     1052                 (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) )
    10051053            {
    10061054                data_t mask = be2mask(be);
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r468 r477  
    115115        DCACHE_XTN_IT_INVAL,
    116116        DCACHE_XTN_DC_FLUSH,
     117        DCACHE_XTN_DC_FLUSH_DATA,
    117118        DCACHE_XTN_DC_FLUSH_GO,
    118119        DCACHE_XTN_DC_INVAL_VA,
     
    120121        DCACHE_XTN_DC_INVAL_END,
    121122        DCACHE_XTN_DC_INVAL_GO,
     123        DCACHE_XTN_DC_INVAL_DATA,
    122124        DCACHE_XTN_DT_INVAL,
    123125        //handling dirty bit update
     
    127129        DCACHE_MISS_SELECT,
    128130        DCACHE_MISS_CLEAN,
     131        DCACHE_MISS_DATA,
    129132        DCACHE_MISS_WAIT,
    130133        DCACHE_MISS_DATA_UPDT,
     
    138141        DCACHE_CC_UPDT,
    139142        DCACHE_CC_INVAL,
     143        DCACHE_CC_INVAL_DATA,
    140144        // handling TLB inval (after a coherence or XTN request)
    141145        DCACHE_INVAL_TLB_SCAN,
     
    188192        CC_SEND_CLEANUP_1,
    189193        CC_SEND_CLEANUP_2,
     194        CC_SEND_CLEANUP_DATA_UPDT,
    190195        CC_SEND_MULTI_ACK,
    191196    };
     
    283288        TYPE_INS_MISS     = 0x3,
    284289    };
     290
     291    //////////////////MODIFIED////////////////
     292    enum content_line_cache_status_e
     293    {
     294        LINE_CACHE_DATA_NOT_DIRTY,
     295        LINE_CACHE_DATA_DIRTY,
     296        LINE_CACHE_IN_TLB,
     297        LINE_CACHE_CONTAINS_PTD,
     298    };
     299    //////////////////////////////////////////
    285300
    286301public:
     
    390405    // communication between ICACHE FSM and CC_SEND FSM
    391406    sc_signal<bool>         r_icache_cc_send_req;           // ICACHE cc_send request
    392     sc_signal<cc_send_t>    r_icache_cc_send_type;          // ICACHE cc_send request type
     407    sc_signal<int>          r_icache_cc_send_type;          // ICACHE cc_send request type
    393408    sc_signal<paddr_t>      r_icache_cc_send_nline;         // ICACHE cc_send nline
    394409    sc_signal<size_t>       r_icache_cc_send_way;           // ICACHE cc_send way
     
    429444    sc_signal<uint32_t>     r_dcache_vci_sc_data;       // SC data (command)
    430445
     446    //RWT: local cas
     447    sc_signal<bool>         r_cas_islocal;
     448    sc_signal<size_t>       r_cas_local_way;
     449    sc_signal<size_t>       r_cas_local_set;
     450    sc_signal<size_t>       r_cas_local_word;
     451
    431452    // register used for XTN inval
    432453    sc_signal<size_t>       r_dcache_xtn_way;               // selected way (from dcache)
     
    447468    sc_signal<size_t>       r_dcache_cc_way;                // selected way for cc update/inval
    448469    sc_signal<size_t>       r_dcache_cc_set;                // selected set for cc update/inval
     470    sc_signal<int>          r_dcache_cc_state;          // state of selected cache slot
    449471    sc_signal<size_t>       r_dcache_cc_word;               // word counter for cc update
    450472    sc_signal<bool>         r_dcache_cc_need_write;     // activate the cache for writing
     473    sc_signal<paddr_t>      r_dcache_cc_inval_addr;     // address for a cleanup transaction
     474    sc_signal<uint32_t>     r_dcache_cc_inval_data_cpt; 
    451475
    452476    // coherence clack handling
     
    483507    // communication between DCACHE FSM and CC_SEND FSM
    484508    sc_signal<bool>         r_dcache_cc_send_req;           // DCACHE cc_send request
    485     sc_signal<cc_send_t>    r_dcache_cc_send_type;          // DCACHE cc_send request type
     509    sc_signal<int>          r_dcache_cc_send_type;          // DCACHE cc_send request type
    486510    sc_signal<paddr_t>      r_dcache_cc_send_nline;         // DCACHE cc_send nline
    487511    sc_signal<size_t>       r_dcache_cc_send_way;           // DCACHE cc_send way
    488512    sc_signal<size_t>       r_dcache_cc_send_updt_tab_idx;  // DCACHE cc_send update table index
    489 
     513   
     514    // special registers for ODCCP/RWT
     515    sc_signal<bool>         r_dcache_cc_cleanup_updt_data;          // Register for cleanup with data (wb updt)
     516    sc_signal<bool>         r_dcache_cc_cleanup_line_ncc;          // Register for cleanup with data (wb updt)
     517    sc_signal<bool>         r_dcache_miss_victim_no_coherence;      // Register for victim in no coherence mode
     518    sc_signal<bool>         r_dcache_line_no_coherence;             // Register for line current in no coherence mode
     519    sc_signal<bool>         r_dcache_dirty_save;             
     520    sc_signal<uint32_t>     r_cc_send_cpt_word;
     521    sc_signal<uint32_t>     r_dcache_miss_data_cpt;
     522    sc_signal<paddr_t>      r_dcache_miss_data_addr;
     523    sc_signal<uint32_t>     r_dcache_xtn_flush_data_cpt;
     524    sc_signal<paddr_t>      r_dcache_xtn_flush_addr_data;
     525    sc_signal<int>          r_dcache_xtn_state;
     526    sc_signal<paddr_t>      r_dcache_xtn_data_addr;
     527    sc_signal<uint32_t>     r_dcache_xtn_data_cpt;
    490528    // dcache directory extension
    491     bool                    *r_dcache_in_tlb;               // copy exist in dtlb or itlb
    492     bool                    *r_dcache_contains_ptd;         // cache line contains a PTD
    493 
     529    ///////////////////////////MODIFIED///////////////////////////////////////////////////
     530    //bool                    *r_dcache_in_tlb;           // copy exist in dtlb or itlb
     531    //bool                    *r_dcache_contains_ptd;     // cache line contains a PTD
     532    int                     *r_dcache_content_state;    // content state of one cache line
     533    int                     *r_dcache_dirty_word;    // content state of one cache line
     534    //////////////////////////////////////////////////////////////////////////////////////
     535
     536    //RWT
     537    sc_signal<bool>         r_dcache_read_state;
     538   
     539     ///////////////////////////////////
    494540    // Physical address extension for data access
    495541    sc_signal<uint32_t>     r_dcache_paddr_ext;             // CP2 register (if vci_address > 32)
     
    513559    GenericFifo<uint32_t>   r_vci_rsp_fifo_icache;              // response FIFO to ICACHE FSM
    514560    GenericFifo<uint32_t>   r_vci_rsp_fifo_dcache;              // response FIFO to DCACHE FSM
     561   
     562
     563    //RWT
     564    GenericFifo<bool>       r_vci_rsp_fifo_rpktid;
     565
     566    GenericFifo<uint32_t>   r_cc_send_data_fifo;   
    515567
    516568    ///////////////////////////////////
     
    534586    // communication between CC_RECEIVE FSM and ICACHE FSM
    535587    sc_signal<bool>         r_cc_receive_icache_req;        // cc_receive to icache request
    536     sc_signal<cc_receive_t> r_cc_receive_icache_type;       // cc_receive type of request
     588    sc_signal<int>          r_cc_receive_icache_type;       // cc_receive type of request
    537589    sc_signal<size_t>       r_cc_receive_icache_way;        // cc_receive to icache way
    538590    sc_signal<size_t>       r_cc_receive_icache_set;        // cc_receive to icache set
     
    542594    // communication between CC_RECEIVE FSM and DCACHE FSM
    543595    sc_signal<bool>         r_cc_receive_dcache_req;        // cc_receive to dcache request
    544     sc_signal<cc_receive_t> r_cc_receive_dcache_type;       // cc_receive type of request
     596    sc_signal<int>          r_cc_receive_dcache_type;       // cc_receive type of request
    545597    sc_signal<size_t>       r_cc_receive_dcache_way;        // cc_receive to dcache way
    546598    sc_signal<size_t>       r_cc_receive_dcache_set;        // cc_receive to dcache set
     
    593645    uint32_t m_cpt_data_read;               // total number of read data
    594646    uint32_t m_cpt_data_write;              // total number of write data
     647    uint32_t m_cpt_data_write_back;
     648    uint32_t m_cpt_data_cleanup;
     649    uint32_t m_cpt_data_sc;
    595650    uint32_t m_cpt_data_miss;               // number of read miss
    596651    uint32_t m_cpt_ins_miss;                // number of instruction miss
     
    608663    uint32_t m_cpt_dmiss_transaction;       // number of VCI data miss transactions
    609664    uint32_t m_cpt_unc_transaction;         // number of VCI uncached read transactions
     665    uint32_t m_cpt_dunc_transaction;         // number of VCI uncached read transactions
     666    uint32_t m_cpt_ll_transaction;         // number of VCI uncached read transactions
    610667    uint32_t m_cpt_write_transaction;       // number of VCI write transactions
    611668    uint32_t m_cpt_icache_unc_transaction;
     
    673730    uint32_t m_cpt_cc_cleanup_ins;              // number of coherence cleanup packets
    674731    uint32_t m_cpt_cc_cleanup_data;             // number of coherence cleanup packets
     732    uint32_t m_cpt_cleanup_data_not_dirty;
     733    uint32_t m_cpt_cleanup_data_dirty_word;
    675734
    676735    uint32_t m_cpt_icleanup_transaction;        // number of instruction cleanup transactions
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r473 r477  
    3535#define DEBUG_ICACHE            1
    3636#define DEBUG_CMD               0
     37#define INSTRUMENTATION     1
    3738
    3839namespace soclib {
     
    8788        "DCACHE_XTN_IT_INVAL",
    8889        "DCACHE_XTN_DC_FLUSH",
     90        "DCACHE_XTN_DC_FLUSH_DATA",
    8991        "DCACHE_XTN_DC_FLUSH_GO",
    9092        "DCACHE_XTN_DC_INVAL_VA",
     
    9294        "DCACHE_XTN_DC_INVAL_END",
    9395        "DCACHE_XTN_DC_INVAL_GO",
     96        "DCACHE_XTN_DC_INVAL_DATA",
    9497        "DCACHE_XTN_DT_INVAL",
    9598
     
    99102        "DCACHE_MISS_SELECT",
    100103        "DCACHE_MISS_CLEAN",
     104        "DCACHE_MISS_DATA",
    101105        "DCACHE_MISS_WAIT",
    102106        "DCACHE_MISS_DATA_UPDT",
     
    110114        "DCACHE_CC_UPDT",
    111115        "DCACHE_CC_INVAL",
     116        "DCACHE_CC_INVAL_DATA",
    112117
    113118        "DCACHE_INVAL_TLB_SCAN",
     
    174179        "CC_SEND_CLEANUP_1",
    175180        "CC_SEND_CLEANUP_2",
     181        "CC_SEND_CLEANUP_DATA_UPDT",
    176182        "CC_SEND_MULTI_ACK",
    177183    };
     
    367373      r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2),        // 2 words depth
    368374      r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2),        // 2 words depth
     375      r_vci_rsp_fifo_rpktid("r_vci_rsp_fifo_rpktid", 2),    // 2 words depth
     376      r_cc_send_data_fifo("r_cc_send_data_fifo", 2),
    369377
    370378      r_cc_send_fsm("r_cc_send_fsm"),
     
    424432    r_mmu_release = (uint32_t)(1 << 16) | 0x1;
    425433
    426     r_dcache_in_tlb       = new bool[dcache_ways*dcache_sets];
    427     r_dcache_contains_ptd = new bool[dcache_ways*dcache_sets];
     434    ////////////////////MODIFIED///////////////////////////////
     435    //r_dcache_in_tlb        = new bool[dcache_ways*dcache_sets];
     436    //r_dcache_contains_ptd  = new bool[dcache_ways*dcache_sets];
     437    r_dcache_content_state = new int [dcache_ways*dcache_sets];
     438    r_dcache_dirty_word    = new int [dcache_ways*dcache_sets*dcache_words];
     439    ///////////////////////////////////////////////////////////
     440
    428441
    429442    SC_METHOD(transition);
     
    450463/////////////////////////////////////
    451464{
    452     delete [] r_dcache_in_tlb;
    453     delete [] r_dcache_contains_ptd;
     465    ////////////MODIFIED/////////////
     466    //delete [] r_dcache_in_tlb;
     467    //delete [] r_dcache_contains_ptd;
     468    delete [] r_dcache_content_state;
     469    delete [] r_dcache_dirty_word;
     470    /////////////////////////////////
    454471}
    455472
     
    472489    // b4 : dtlb trace
    473490    // b5 : itlb trace
    474 
    475491    std::cout << std::dec << "PROC " << name() << std::endl;
    476492
     
    479495    std::cout << "  " << m_dreq << std::endl;
    480496    std::cout << "  " << m_drsp << std::endl;
     497
     498    /**/std::cout << r_iss << std::endl;
    481499
    482500    std::cout << "  " << icache_fsm_state_str[r_icache_fsm.read()]
     
    562580}
    563581
    564 /*
     582
    565583////////////////////////
    566584tmpl(void)::print_stats()
     
    569587    float run_cycles = (float)(m_cpt_total_cycles - m_cpt_frz_cycles);
    570588    std::cout << name() << std::endl
    571         << "- CPI                    = " << (float)m_cpt_total_cycles/run_cycles << std::endl
    572         << "- READ RATE              = " << (float)m_cpt_read/run_cycles << std::endl
    573         << "- WRITE RATE             = " << (float)m_cpt_write/run_cycles << std::endl
    574         << "- IMISS_RATE             = " << (float)m_cpt_ins_miss/m_cpt_ins_read << std::endl
    575         << "- DMISS RATE             = " << (float)m_cpt_data_miss/(m_cpt_read-m_cpt_unc_read) << std::endl
    576         << "- INS MISS COST          = " << (float)m_cost_ins_miss_frz/m_cpt_ins_miss << std::endl
    577         << "- DATA MISS COST         = " << (float)m_cost_data_miss_frz/m_cpt_data_miss << std::endl
    578         << "- WRITE COST             = " << (float)m_cost_write_frz/m_cpt_write << std::endl
    579         << "- UNC COST               = " << (float)m_cost_unc_read_frz/m_cpt_unc_read << std::endl
    580         << "- UNCACHED READ RATE     = " << (float)m_cpt_unc_read/m_cpt_read << std::endl
    581         << "- CACHED WRITE RATE      = " << (float)m_cpt_write_cached/m_cpt_write << std::endl
    582         << "- INS TLB MISS RATE      = " << (float)m_cpt_ins_tlb_miss/m_cpt_ins_tlb_read << std::endl
    583         << "- DATA TLB MISS RATE     = " << (float)m_cpt_data_tlb_miss/m_cpt_data_tlb_read << std::endl
    584         << "- ITLB MISS COST         = " << (float)m_cost_ins_tlb_miss_frz/m_cpt_ins_tlb_miss << std::endl
    585         << "- DTLB MISS COST         = " << (float)m_cost_data_tlb_miss_frz/m_cpt_data_tlb_miss << std::endl
    586         << "- ITLB UPDATE ACC COST   = " << (float)m_cost_ins_tlb_update_acc_frz/m_cpt_ins_tlb_update_acc << std::endl
    587         << "- DTLB UPDATE ACC COST   = " << (float)m_cost_data_tlb_update_acc_frz/m_cpt_data_tlb_update_acc << std::endl
    588         << "- DTLB UPDATE DIRTY COST = " << (float)m_cost_data_tlb_update_dirty_frz/m_cpt_data_tlb_update_dirty << std::endl
    589         << "- ITLB HIT IN DCACHE RATE= " << (float)m_cpt_ins_tlb_hit_dcache/m_cpt_ins_tlb_miss << std::endl
    590         << "- DTLB HIT IN DCACHE RATE= " << (float)m_cpt_data_tlb_hit_dcache/m_cpt_data_tlb_miss << std::endl
    591         << "- DCACHE FROZEN BY ITLB  = " << (float)m_cost_ins_tlb_occup_cache_frz/m_cpt_dcache_frz_cycles << std::endl
    592         << "- DCACHE FOR TLB %       = " << (float)m_cpt_tlb_occup_dcache/(m_dcache_ways*m_dcache_sets) << std::endl
    593         << "- NB CC BROADCAST        = " << m_cpt_cc_broadcast << std::endl
    594         << "- NB CC UPDATE DATA      = " << m_cpt_cc_update_data << std::endl
    595         << "- NB CC INVAL DATA       = " << m_cpt_cc_inval_data << std::endl
    596         << "- NB CC INVAL INS        = " << m_cpt_cc_inval_ins << std::endl
    597         << "- CC BROADCAST COST      = " << (float)m_cost_broadcast_frz/m_cpt_cc_broadcast << std::endl
    598         << "- CC UPDATE DATA COST    = " << (float)m_cost_updt_data_frz/m_cpt_cc_update_data << std::endl
    599         << "- CC INVAL DATA COST     = " << (float)m_cost_inval_data_frz/m_cpt_cc_inval_data << std::endl
    600         << "- CC INVAL INS COST      = " << (float)m_cost_inval_ins_frz/m_cpt_cc_inval_ins << std::endl
    601         << "- NB CC CLEANUP DATA     = " << m_cpt_cc_cleanup_data << std::endl
    602         << "- NB CC CLEANUP INS      = " << m_cpt_cc_cleanup_ins << std::endl
    603         << "- IMISS TRANSACTION      = " << (float)m_cost_imiss_transaction/m_cpt_imiss_transaction << std::endl
    604         << "- DMISS TRANSACTION      = " << (float)m_cost_dmiss_transaction/m_cpt_dmiss_transaction << std::endl
    605         << "- UNC TRANSACTION        = " << (float)m_cost_unc_transaction/m_cpt_unc_transaction << std::endl
    606         << "- WRITE TRANSACTION      = " << (float)m_cost_write_transaction/m_cpt_write_transaction << std::endl
    607         << "- WRITE LENGTH           = " << (float)m_length_write_transaction/m_cpt_write_transaction << std::endl
    608         << "- ITLB MISS TRANSACTION  = " << (float)m_cost_itlbmiss_transaction/m_cpt_itlbmiss_transaction << std::endl
    609         << "- DTLB MISS TRANSACTION  = " << (float)m_cost_dtlbmiss_transaction/m_cpt_dtlbmiss_transaction << std::endl;
     589        << "- CPI                     = " << std::dec <<(float)m_cpt_total_cycles/run_cycles << std::endl
     590        << "- READ RATE               = " << (float)m_cpt_data_read/run_cycles << std::endl
     591        << "- WRITE RATE              = " << (float)m_cpt_data_write/run_cycles << std::endl
     592        << "- IMISS_RATE              = " << (float)m_cpt_ins_miss/m_cpt_ins_read << std::endl
     593        << "- DMISS RATE              = " << (float)m_cpt_data_miss/(m_cpt_data_read-m_cpt_unc_read) << std::endl
     594        << "- INS MISS COST           = " << (float)m_cost_ins_miss_frz/m_cpt_ins_miss << std::endl
     595        << "- DATA MISS COST          = " << (float)m_cost_data_miss_frz/m_cpt_data_miss << std::endl
     596        << "- WRITE COST              = " << (float)m_cost_write_frz/m_cpt_data_write << std::endl
     597        << "- UNC COST                = " << (float)m_cost_unc_read_frz/m_cpt_unc_read << std::endl
     598        << "- UNCACHED READ RATE      = " << (float)m_cpt_unc_read/m_cpt_data_read << std::endl
     599        << "- CACHED WRITE RATE       = " << (float)m_cpt_write_cached/m_cpt_data_write << std::endl
     600        << "- INS TLB MISS RATE       = " << (float)m_cpt_ins_tlb_miss/m_cpt_ins_tlb_read << std::endl
     601        << "- DATA TLB MISS RATE      = " << (float)m_cpt_data_tlb_miss/m_cpt_data_tlb_read << std::endl
     602        << "- ITLB MISS COST          = " << (float)m_cost_ins_tlb_miss_frz/m_cpt_ins_tlb_miss << std::endl
     603        << "- DTLB MISS COST          = " << (float)m_cost_data_tlb_miss_frz/m_cpt_data_tlb_miss << std::endl
     604        << "- ITLB UPDATE ACC COST    = " << (float)m_cost_ins_tlb_update_acc_frz/m_cpt_ins_tlb_update_acc << std::endl
     605        << "- DTLB UPDATE ACC COST    = " << (float)m_cost_data_tlb_update_acc_frz/m_cpt_data_tlb_update_acc << std::endl
     606        << "- DTLB UPDATE DIRTY COST  = " << (float)m_cost_data_tlb_update_dirty_frz/m_cpt_data_tlb_update_dirty << std::endl
     607        << "- ITLB HIT IN DCACHE RATE = " << (float)m_cpt_ins_tlb_hit_dcache/m_cpt_ins_tlb_miss << std::endl
     608        << "- DTLB HIT IN DCACHE RATE = " << (float)m_cpt_data_tlb_hit_dcache/m_cpt_data_tlb_miss << std::endl
     609        //<< "- DCACHE FROZEN BY ITLB   = " << (float)m_cost_ins_tlb_occup_cache_frz/m_cpt_dcache_frz_cycles << std::endl
     610        << "- DCACHE FOR TLB %        = " << (float)m_cpt_tlb_occup_dcache/(m_dcache_ways*m_dcache_sets) << std::endl
     611        << "- NB CC BROADCAST         = " << m_cpt_cc_broadcast << std::endl
     612        << "- NB CC UPDATE DATA       = " << m_cpt_cc_update_dcache << std::endl
     613        << "- NB CC INVAL DATA        = " << m_cpt_cc_inval_dcache << std::endl
     614        << "- NB CC INVAL INS         = " << m_cpt_cc_inval_icache << std::endl
     615        << "- CC BROADCAST COST       = " << (float)m_cost_broadcast_frz/m_cpt_cc_broadcast << std::endl
     616        << "- CC UPDATE DATA COST     = " << (float)m_cost_updt_data_frz/m_cpt_cc_update_dcache << std::endl
     617        << "- CC INVAL DATA COST      = " << (float)m_cost_inval_data_frz/m_cpt_cc_inval_dcache << std::endl
     618        << "- CC INVAL INS COST       = " << (float)m_cost_inval_ins_frz/m_cpt_cc_inval_icache << std::endl
     619        << "- NB CC CLEANUP DATA      = " << m_cpt_cc_cleanup_data << std::endl
     620        << "- NB CC CLEANUP INS       = " << m_cpt_cc_cleanup_ins << std::endl
     621        << "- IMISS TRANSACTION       = " << (float)m_cost_imiss_transaction/m_cpt_imiss_transaction << std::endl
     622        << "- DMISS TRANSACTION       = " << (float)m_cost_dmiss_transaction/m_cpt_dmiss_transaction << std::endl
     623        << "- UNC TRANSACTION         = " << (float)m_cost_unc_transaction/m_cpt_unc_transaction << std::endl
     624        << "- WRITE TRANSACTION       = " << (float)m_cost_write_transaction/m_cpt_write_transaction << std::endl
     625        << "- NB WRITE TRANSACTION    = " << m_cpt_write_transaction << std::endl
     626        << "- NB WRITE WORDS VCI      = " << m_length_write_transaction << std::endl
     627        << "- NB WRITE PROC           = " << m_cpt_data_write << std::endl
     628        << "- NB WRITE BACK           = " << m_cpt_data_write_back << std::endl
     629        << "- NB WRITE BACK COHERENCE = " << m_cpt_data_cleanup << std::endl
     630        << "- NB DATA SC              = " << m_cpt_data_sc << std::endl
     631        << "- WRITE LENGTH            = " << (float)m_length_write_transaction/m_cpt_write_transaction << std::endl
     632        << "- ITLB MISS TRANSACTION   = " << (float)m_cost_itlbmiss_transaction/m_cpt_itlbmiss_transaction << std::endl
     633        << "- DTLB MISS TRANSACTION   = " << (float)m_cost_dtlbmiss_transaction/m_cpt_dtlbmiss_transaction << std::endl
     634
     635        << "- DMISS TRANSACTION       = " << m_cpt_dmiss_transaction << std::endl
     636        << "- DUNC TRANSACTION        = " << m_cpt_dunc_transaction << std::endl
     637        << "- LL TRANSACTION          = " << m_cpt_ll_transaction << std::endl
     638        << "- CLEANUP DATA NOT DIRTY  = " << m_cpt_cleanup_data_not_dirty << std::endl
     639        << "- CLEANUP DATA DIRTY WORD = " << m_cpt_cleanup_data_dirty_word << std::endl;
    610640}
    611641
     
    624654
    625655    m_cpt_frz_cycles        = 0;
    626     m_cpt_dcache_frz_cycles = 0;
     656//    m_cpt_dcache_frz_cycles = 0;
    627657    m_cpt_total_cycles      = 0;
    628658
    629     m_cpt_read         = 0;
    630     m_cpt_write        = 0;
     659//    m_cpt_read         = 0;
     660//    m_cpt_write        = 0;
    631661    m_cpt_data_miss    = 0;
    632662    m_cpt_ins_miss     = 0;
     
    692722    m_cost_dtlb_sc_dirty_transaction = 0;
    693723
    694     m_cpt_cc_update_data = 0;
    695     m_cpt_cc_inval_ins   = 0;
    696     m_cpt_cc_inval_data  = 0;
     724//    m_cpt_cc_update_data = 0;
     725//    m_cpt_cc_inval_ins   = 0;
     726//    m_cpt_cc_inval_data  = 0;
    697727    m_cpt_cc_broadcast   = 0;
    698728
     
    704734    m_cpt_cc_cleanup_data = 0;
    705735    m_cpt_cc_cleanup_ins  = 0;
     736
     737    m_cpt_cleanup_data_not_dirty  = 0;
     738    m_cpt_cleanup_data_dirty_word = 0;
     739
    706740}
    707741
    708 */
     742
    709743
    710744/////////////////////////
     
    734768        for (size_t i=0 ; i< m_dcache_ways*m_dcache_sets ; i++)
    735769        {
    736             r_dcache_in_tlb[i]       = false;
    737             r_dcache_contains_ptd[i] = false;
     770            // MODIFIED
     771            //r_dcache_in_tlb[i]        = false;
     772            //r_dcache_contains_ptd[i]  = false;
     773            r_dcache_content_state[i] = LINE_CACHE_DATA_NOT_DIRTY;
     774            r_dcache_dirty_word[i] = 0;
    738775        }
    739776
     
    741778        r_vci_rsp_fifo_icache.init();
    742779        r_vci_rsp_fifo_dcache.init();
     780        r_cc_send_data_fifo.init();
    743781
    744782        // ICACHE & DCACHE activated
     
    805843        m_debug_previous_d_hit     = false;
    806844        m_debug_activated              = false;
     845
     846        // SPECIAL REGISTERS ODCCP
     847        r_dcache_cc_cleanup_updt_data = false;
     848        r_dcache_cc_cleanup_line_ncc  = false;
     849        r_dcache_miss_victim_no_coherence = false;
     850        r_dcache_line_no_coherence = false;
     851        r_cc_send_cpt_word = 0;
     852        r_dcache_miss_data_cpt = 0;
     853        r_dcache_miss_data_addr = 0;
    807854
    808855        // activity counters
     
    821868
    822869        m_cpt_data_miss         = 0;
     870        m_cpt_data_write        = 0;
     871        m_cpt_data_sc           = 0;
     872        m_cpt_data_write_back   = 0;
     873        m_cpt_data_cleanup      = 0;
     874        m_cpt_cleanup_data_not_dirty = 0;
    823875        m_cpt_ins_miss          = 0;
    824876        m_cpt_unc_read          = 0;
     
    879931            m_cpt_cc_cleanup_data = 0;
    880932            m_cpt_cc_cleanup_ins  = 0;
     933
     934        m_cpt_cleanup_data_not_dirty  = 0;
     935        m_cpt_cleanup_data_dirty_word = 0;
    881936
    882937        m_cpt_itlbmiss_transaction      = 0;
     
    926981    bool       vci_rsp_fifo_dcache_put   = false;
    927982    uint32_t   vci_rsp_fifo_dcache_data  = 0;
     983    bool       vci_rsp_fifo_rpktid_get   = false;
     984    bool       vci_rsp_fifo_rpktid_put   = false;
     985    bool       vci_rsp_fifo_rpktid       = false;
     986
     987    // FIFO for cleanup data updt
     988    bool       cleanup_data_updt_fifo_dcache_get   = false;
     989    bool       cleanup_data_updt_fifo_dcache_put   = false;
     990    uint32_t   cleanup_data_updt_fifo_dcache_data  = 0;
    928991
    929992    // updt fifo
     
    935998
    936999#ifdef INSTRUMENTATION
    937     m_cpt_fsm_dcache  [r_dcache_fsm.read() ] ++;
    938     m_cpt_fsm_icache  [r_icache_fsm.read() ] ++;
    939     m_cpt_fsm_cmd     [r_vci_cmd_fsm.read()] ++;
    940     m_cpt_fsm_rsp     [r_vci_rsp_fsm.read()] ++;
    941     m_cpt_fsm_tgt     [r_tgt_fsm.read()    ] ++;
    942     m_cpt_fsm_cleanup [r_cleanup_cmd_fsm.read()] ++;
     1000    m_cpt_fsm_dcache     [r_dcache_fsm.read()    ] ++;
     1001    m_cpt_fsm_icache     [r_icache_fsm.read()    ] ++;
     1002    m_cpt_fsm_cmd        [r_vci_cmd_fsm.read()   ] ++;
     1003    m_cpt_fsm_rsp        [r_vci_rsp_fsm.read()   ] ++;
     1004    m_cpt_fsm_cc_send    [r_cc_send_fsm.read()   ] ++;
     1005    m_cpt_fsm_cc_receive [r_cc_receive_fsm.read()] ++;
    9431006#endif
    9441007
     
    10691132                else
    10701133                {
    1071                                 r_icache_vci_paddr = (paddr_t)r_mmu_word_hi.read() << 32 |
     1134                                r_icache_vci_paddr = (uint64_t)r_mmu_word_hi.read() << 32 |
    10721135                                                         (paddr_t)r_mmu_word_lo.read();
    10731136                        }
     
    11061169
    11071170#ifdef INSTRUMENTATION
    1108 m_cpt_itlb_read++;
     1171m_cpt_ins_tlb_read++;
    11091172#endif
    11101173                tlb_hit = r_itlb.translate( m_ireq.addr,
     
    11811244
    11821245#ifdef INSTRUMENTATION
    1183 m_cpt_itlb_miss++;
     1246m_cpt_ins_tlb_miss++;
    11841247#endif
    11851248                    r_icache_fsm          = ICACHE_TLB_WAIT;
     
    11991262
    12001263#ifdef INSTRUMENTATION
    1201 m_cpt_icache_miss++;
     1264m_cpt_ins_miss++;
    12021265#endif
    12031266                    // we request a VCI transaction
     
    13401403                               &state );
    13411404
    1342             if ( state == CACHE_SLOT_STATE_VALID )    // inval required
     1405            if ( state == CACHE_SLOT_STATE_VALID_CC )    // inval required
    13431406            {
    13441407                // request cleanup
     
    14211484
    14221485#ifdef INSTRUMENTATION
    1423 m_cpt_itlb_read++;
     1486m_cpt_ins_tlb_read++;
    14241487#endif
    14251488            hit = r_itlb.translate(r_dcache_save_wdata.read(),
     
    14411504
    14421505#ifdef INSTRUMENTATION
    1443 m_cpt_itlb_miss++;
     1506m_cpt_ins_tlb_miss++;
    14441507#endif
    14451508            r_icache_tlb_miss_req = true;
     
    14681531                          &word);
    14691532
    1470         if ( state == CACHE_SLOT_STATE_VALID )  // inval to be done
     1533        if ( state == CACHE_SLOT_STATE_VALID_CC )       // inval to be done
    14711534        {
    14721535            r_icache_miss_way = way;
     
    17511814                                    r_icache_miss_way.read(),
    17521815                                    r_icache_miss_set.read(),
    1753                                     CACHE_SLOT_STATE_VALID );
     1816                                    CACHE_SLOT_STATE_VALID_CC );
    17541817#if DEBUG_ICACHE
    17551818if ( m_debug_activated )
     
    19241987        r_icache_cc_set = set;
    19251988
    1926         if ( state == CACHE_SLOT_STATE_VALID)            // hit
     1989        if ( state == CACHE_SLOT_STATE_VALID_CC)            // hit
    19271990        {
    19281991            // need to update the cache state
     
    21362199    m_drsp.error = false;
    21372200    m_drsp.rdata = 0;
     2201    //if(m_cpt_total_cycles % 1000000 == 0 ) r_dcache.printTrace();
    21382202
    21392203    switch ( r_dcache_fsm.read() )
     
    21912255        bool        wbuf_request       = false;     // request WBUF write in P1 stage
    21922256
     2257
    21932258        // physical address computation : systematic DTLB access if activated)
    21942259        if ( m_dreq.valid )
     
    22032268                                            &tlb_set );
    22042269#ifdef INSTRUMENTATION
    2205 m_cpt_dtlb_read++;
     2270m_cpt_data_tlb_read++;
    22062271#endif
    22072272            }
     
    22112276                // we take into account the paddr extension
    22122277                if (vci_param::N > 32)
    2213                     paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
     2278                    paddr = paddr | ((uint64_t)(r_dcache_paddr_ext.read()) << 32);
    22142279            }
    22152280        } // end physical address computation
     
    22682333            size_t way = r_dcache_save_cache_way.read();
    22692334            size_t set = r_dcache_save_cache_set.read();
    2270 
    2271             if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
     2335            // MODIFIED
     2336            //if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
     2337            //{
     2338            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    22722339            {
    22732340                tlb_inval_required       = true;
     
    22752342                    r_dcache_tlb_inval_line  = r_dcache_save_paddr.read()>>
    22762343                                           (uint32_log2(m_dcache_words<<2));
    2277                     r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    2278             }
    2279             else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
     2344                // MODIFIED RWT: DIRTY
     2345                    //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     2346                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     2347            }
     2348            // MODIFIED
     2349            //else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
     2350            //{
     2351            else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
    22802352            {
    22812353                r_itlb.reset();
    22822354                r_dtlb.reset();
    2283                     r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     2355                // MODIFIED
     2356                    //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     2357                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    22842358            }
    22852359
     
    23122386                                         r_dcache_save_wdata.read(),
    23132387                                         r_dcache_save_cacheable.read() );
    2314 #ifdef INSTRUMENTATION
     2388/*#ifdef INSTRUMENTATION
    23152389m_cpt_wbuf_write++;
    2316 #endif
     2390#endif*/
    23172391                if ( not wok ) // miss if write buffer full
    23182392                {
     
    25262600                        else
    25272601                        {
    2528                             r_dcache_save_paddr = (paddr_t)r_mmu_word_hi.read() << 32 |
     2602                            r_dcache_save_paddr = (uint64_t)r_mmu_word_hi.read() << 32 |
    25292603                                                  (paddr_t)r_mmu_word_lo.read();
    25302604                        }
     
    26232697                        if ( not (r_mmu_mode.read() & DATA_CACHE_MASK) ) cacheable = false;
    26242698                        else cacheable = tlb_flags.c;
    2625 
    26262699                        // access rights checking
    26272700                        if ( not tlb_flags.u and (m_dreq.mode == iss_t::MODE_USER))
     
    26932766                            {
    26942767#ifdef INSTRUMENTATION
    2695 m_cpt_dcache_miss++;
    2696 #endif
     2768m_cpt_data_miss++;
     2769#endif
     2770                                /*ODCCP*/
     2771                                //std::cout << "\t\t\t\t\tCACHE MISS NEED READ for : " << name() << std::endl;
    26972772                                // request a VCI DMISS transaction
    26982773                                r_dcache_vci_paddr    = paddr;
     
    27232798m_cpt_data_read++;
    27242799#endif
     2800                                /*if ((tlb_flags.s == 0) and (r_mmu_mode.read() & DATA_TLB_MASK) and (cache_state == CACHE_SLOT_STATE_VALID_CC))
     2801                                {
     2802                                    //ODCCP
     2803                                    std::cout << "READ NO COHERENCE on " << name() << " | paddr = " << std::hex << paddr << std::dec << " | way = " << cache_way << " | set = " << cache_set << " | at cycle : "<< m_cpt_total_cycles << std::endl;
     2804                                    r_dcache.write_dir(cache_way,
     2805                                                       cache_set,
     2806                                                       CACHE_SLOT_STATE_VALID_NCC);
     2807                                }*/
    27252808                                // returns data to processor
    27262809                                m_drsp.valid   = true;
     
    27652848                        r_dcache_ll_rsp_count = 0;
    27662849                        r_dcache_fsm          = DCACHE_LL_WAIT;
     2850                        /*ODCCP*/
     2851                        //std::cout << "LL on " << name() << " | paddr = " << std::hex << paddr << std::dec << " | at cycle : " << m_cpt_total_cycles << std::endl;
    27672852
    27682853                    }// end LL
     
    28062891                            // response to processor
    28072892                            m_drsp.valid        = true;
    2808 
    28092893                            // activating P1 stage
    2810                             wbuf_request = true;
    2811                             updt_request = (cache_state == CACHE_SLOT_STATE_VALID);
     2894                            if( (cache_state != CACHE_SLOT_STATE_ZOMBI )&&(cache_state != CACHE_SLOT_STATE_EMPTY )&&(cacheable) )
     2895                            {
     2896                                wbuf_request = (cache_state == CACHE_SLOT_STATE_VALID_CC); //write to L2 only if CC
     2897                                updt_request = true;
     2898                                if (cache_state == CACHE_SLOT_STATE_VALID_NCC)
     2899                                {
     2900                                    if (r_dcache_content_state[cache_way*m_dcache_sets+cache_set] == LINE_CACHE_DATA_NOT_DIRTY)
     2901                                    {
     2902                                        r_dcache_content_state[cache_way*m_dcache_sets+cache_set] = LINE_CACHE_DATA_DIRTY;
     2903                                    }
     2904                                    r_dcache_dirty_word[(cache_way*m_dcache_sets +cache_set)*m_dcache_words+cache_word] = 1;//dirty bit with word granularity (only for stats)
     2905                                    m_cpt_data_write_back ++;
     2906                                }
     2907                            }
     2908                            else
     2909                            {
     2910                               wbuf_request = true;
     2911                               updt_request = false;
     2912                            }
    28122913                        }
    28132914                    } // end WRITE
     
    29783079m_cpt_dcache_dir_read++;
    29793080#endif
    2980         if ( cache_state == CACHE_SLOT_STATE_VALID )   // hit in dcache
     3081        /*ODCCP*/
     3082//        assert((cache_state != CACHE_SLOT_STATE_VALID_NCC) and "DCACHE_TLB_PTE1_GET : IMPOSSIBLE NCC HERE");
     3083//        if ( cache_state == CACHE_SLOT_STATE_VALID_CC )   // hit in dcache
     3084        if (( cache_state == CACHE_SLOT_STATE_VALID_NCC ) or ( cache_state == CACHE_SLOT_STATE_VALID_CC ))
    29813085        {
    29823086            if ( not (entry & PTE_V_MASK) )     // unmapped
     
    30153119            {
    30163120                // mark the cache line ac containing a PTD
    3017                 r_dcache_contains_ptd[m_dcache_sets*way+set] = true;
     3121                //MODIFIED
     3122                //r_dcache_contains_ptd[m_dcache_sets*way+set] = true;
     3123                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_CONTAINS_PTD;
    30183124
    30193125                // register bypass
     
    30503156            else                        //  PTE1 :  we must update the TLB
    30513157            {
    3052                 r_dcache_in_tlb[m_icache_sets*way+set] = true;
     3158                // MODIFIED
     3159                //r_dcache_in_tlb[m_icache_sets*way+set] = true;
     3160                r_dcache_content_state[m_icache_sets*way+set] = LINE_CACHE_IN_TLB;
    30533161                r_dcache_tlb_pte_flags  = entry;
    30543162                r_dcache_tlb_cache_way  = way;
     
    31083216                           &set );
    31093217#ifdef INSTRUMENTATION
    3110 m_cpt_itlb_read++;
     3218m_cpt_ins_tlb_read++;
    31113219#endif
    31123220        }
     
    31183226                           &set );
    31193227#ifdef INSTRUMENTATION
    3120 m_cpt_dtlb_read++;
     3228m_cpt_data_tlb_read++;
    31213229#endif
    31223230        }
     
    31943302                              nline );
    31953303#ifdef INSTRUMENTATION
    3196 m_cpt_itlb_write++;
     3304m_cpt_ins_tlb_update_acc++;
    31973305#endif
    31983306
     
    32183326                              nline );
    32193327#ifdef INSTRUMENTATION
    3220 m_cpt_dtlb_write++;
     3328m_cpt_data_tlb_update_acc++;
    32213329#endif
    32223330
     
    32683376        }
    32693377
    3270         uint32_t        pte_flags;
    3271         uint32_t        pte_ppn;
    3272         size_t          way;
    3273         size_t          set;
    3274         size_t          word;
    3275         int         cache_state;
     3378        uint32_t        pte_flags     = 0;
     3379        uint32_t        pte_ppn       = 0;
     3380        size_t          way           = 0;
     3381        size_t          set           = 0;
     3382        size_t          word          = 0;
     3383        int         cache_state   = 0;
    32763384
    32773385        r_dcache.read( r_dcache_tlb_paddr.read(),
     
    32863394m_cpt_dcache_dir_read++;
    32873395#endif
    3288         if ( cache_state == CACHE_SLOT_STATE_VALID )   // hit in dcache
     3396        /*ODCCP*/
     3397//        assert((cache_state != CACHE_SLOT_STATE_VALID_NCC) and "DCACHE_TLB_PTE2_GET : IMPOSSIBLE NCC HERE");
     3398//        if (cache_state == CACHE_SLOT_STATE_VALID_CC)    // hit in dcache
     3399        if ((cache_state == CACHE_SLOT_STATE_VALID_CC) or (cache_state == CACHE_SLOT_STATE_VALID_NCC))
    32893400        {
    32903401            if ( not (pte_flags & PTE_V_MASK) ) // unmapped
     
    33183429            else                                // mapped : we must update the TLB
    33193430            {
    3320                 r_dcache_in_tlb[m_dcache_sets*way+set] = true;
     3431                // MODIFIED
     3432                //r_dcache_in_tlb[m_dcache_sets*way+set] = true;
     3433                r_dcache_content_state[m_dcache_sets*way+set] = LINE_CACHE_IN_TLB;
    33213434                r_dcache_tlb_pte_flags  = pte_flags;
    33223435                r_dcache_tlb_pte_ppn    = pte_ppn;
     
    33833496                           &set );
    33843497#ifdef INSTRUMENTATION
    3385 m_cpt_itlb_read++;
     3498m_cpt_ins_tlb_read++;
    33863499#endif
    33873500        }
     
    33933506                           &set );
    33943507#ifdef INSTRUMENTATION
    3395 m_cpt_dtlb_read++;
     3508m_cpt_data_tlb_read++;
    33963509#endif
    33973510        }
     
    34353548        // As long as this computation is not done, all access are local.
    34363549
     3550        int  state;
     3551        size_t way;
     3552        size_t set;
     3553        size_t word;
     3554        r_dcache.read_dir(r_dcache_tlb_paddr.read(),
     3555                          &state,
     3556                          &way,
     3557                          &set,
     3558                          &word);
     3559        r_cas_islocal = (state == CACHE_SLOT_STATE_VALID_NCC);//do not check L2 if NCC: the CAS is necessarily a success
     3560        r_cas_local_way = way;
     3561        r_cas_local_set = set;
     3562        r_cas_local_word = word;
     3563
    34373564        if ( local )                                            // local access
    34383565        {
     
    34703597                              nline );
    34713598#ifdef INSTRUMENTATION
    3472 m_cpt_itlb_write++;
     3599m_cpt_ins_tlb_update_acc++;
    34733600#endif
    34743601
     
    34943621                              nline );
    34953622#ifdef INSTRUMENTATION
    3496 m_cpt_dtlb_write++;
     3623m_cpt_data_tlb_update_acc++;
    34973624#endif
    34983625
     
    35283655    case DCACHE_TLB_LR_UPDT:        // request a CAS transaction to update L/R bit
    35293656    {
     3657        uint32_t way  = r_cas_local_way.read();
     3658        uint32_t set  = r_cas_local_set.read();
     3659        uint32_t word = r_cas_local_word.read();
     3660        paddr_t nline = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
    35303661#if DEBUG_DCACHE
    35313662if ( m_debug_activated )
     
    35353666}
    35363667#endif
    3537         // r_dcache_vci_cas_old & r_dcache_vci_cas_new registers are already set
    3538         r_dcache_vci_paddr = r_dcache_tlb_paddr.read();
    3539 
    3540         // checking llsc reservation buffer
    3541         if ( r_dcache_llsc_paddr.read() == r_dcache_tlb_paddr.read() )
    3542             r_dcache_llsc_valid = false;
    3543 
    3544         // request a CAS CMD and go to DCACHE_TLB_LR_WAIT state
    3545         r_dcache_vci_cas_req = true;
    3546         r_dcache_fsm         = DCACHE_TLB_LR_WAIT;
     3668
     3669        if (r_cas_islocal.read())
     3670        {
     3671            r_dcache.write(way,
     3672                           set,
     3673                           word,
     3674                           r_dcache_vci_cas_new.read());
     3675            //compteur dirty
     3676            r_dcache_dirty_word[(way*m_dcache_sets +set)*m_dcache_words+word] = 1;
     3677
     3678            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
     3679            {
     3680                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     3681                r_dcache_tlb_inval_line  = nline;
     3682                r_dcache_tlb_inval_set   = 0;
     3683                r_dcache_fsm_scan_save   = DCACHE_TLB_RETURN;
     3684                r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     3685                break;
     3686            }
     3687
     3688            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     3689            {
     3690                r_itlb.reset();
     3691                r_dtlb.reset();
     3692                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     3693
     3694#if DEBUG_DCACHE
     3695                if ( m_debug_activated )
     3696                {
     3697                    std::cout << "  <PROC " << name()
     3698                        << " DCACHE_TLB_LR_UPDT> Flush DTLB & ITLB" << std::endl;
     3699                }
     3700#endif
     3701            }
     3702
     3703            r_dcache_fsm = DCACHE_TLB_RETURN;
     3704        }
     3705        else
     3706        {
     3707            // r_dcache_vci_cas_old & r_dcache_vci_cas_new registers are already set
     3708          r_dcache_vci_paddr = r_dcache_tlb_paddr.read();
     3709
     3710            // checking llsc reservation buffer
     3711            if ( r_dcache_llsc_paddr.read() == r_dcache_tlb_paddr.read() )
     3712                r_dcache_llsc_valid = false;
     3713
     3714            // request a CAS CMD and go to DCACHE_TLB_LR_WAIT state
     3715            r_dcache_vci_cas_req = true;
     3716            r_dcache_fsm         = DCACHE_TLB_LR_WAIT;
     3717        }
    35473718        break;
    35483719    }
     
    37393910                               &tag,
    37403911                               &state );
    3741 
    3742             if ( state == CACHE_SLOT_STATE_VALID )         // inval required
     3912            /*ODCCP*/
     3913
     3914            if ( state == CACHE_SLOT_STATE_VALID_CC )         // inval required
    37433915            {
    37443916                // request cleanup
     
    37513923                r_dcache_miss_way     = way;
    37523924                r_dcache_miss_set     = set;
     3925                r_dcache_cc_cleanup_line_ncc = false;
     3926                r_dcache_cc_cleanup_updt_data = false;
    37533927                r_dcache_fsm          = DCACHE_XTN_DC_FLUSH_GO;
     3928            }
     3929            else if ( state == CACHE_SLOT_STATE_VALID_NCC)
     3930            {
     3931                // request cleanup
     3932                r_dcache_cc_send_req   = true;
     3933                r_dcache_cc_send_nline = tag * m_dcache_sets + set;
     3934                r_dcache_cc_send_way   = way;
     3935                r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     3936
     3937                // goes to DCACHE_XTN_DC_FLUSH_GO to inval directory
     3938                r_dcache_miss_way     = way;
     3939                r_dcache_miss_set     = set;
     3940                r_dcache_cc_cleanup_line_ncc = true;
     3941                //if (r_dcache_content_state[m_dcache_sets*way+set] != LINE_CACHE_DATA_NOT_DIRTY)//Must send data in the cleanup
     3942                if (true)//Must send data in the cleanup
     3943                {
     3944                    r_dcache_xtn_flush_addr_data = (tag * m_dcache_sets + set) * m_dcache_words * 4;
     3945                    r_dcache_xtn_flush_data_cpt = 0;
     3946                    r_dcache_cc_cleanup_updt_data = true;
     3947                    for (size_t w = 0; w< m_dcache_words; w++)
     3948                    {
     3949                        m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     3950                    }
     3951                    r_dcache_fsm          = DCACHE_XTN_DC_FLUSH_DATA;
     3952                }
     3953                else
     3954                {
     3955                    r_dcache_cc_cleanup_updt_data = false;
     3956                    r_dcache_fsm          = DCACHE_XTN_DC_FLUSH_GO;
     3957                }
    37543958            }
    37553959            else if ( r_dcache_flush_count.read() ==
     
    37683972        break;
    37693973    }
     3974
     3975    ////////////////////////////
     3976    case DCACHE_XTN_DC_FLUSH_DATA:
     3977    {
     3978        uint32_t rdata;
     3979        size_t   way;
     3980        size_t   set;
     3981        size_t   word;
     3982        r_dcache.read_neutral(r_dcache_xtn_flush_addr_data.read(),
     3983                              &rdata,
     3984                              &way,
     3985                              &set,
     3986                              &word);
     3987        if(r_cc_send_data_fifo.wok())
     3988        {
     3989            r_dcache_xtn_flush_addr_data = r_dcache_xtn_flush_addr_data.read() + 4;
     3990
     3991            cleanup_data_updt_fifo_dcache_put   = true;
     3992            cleanup_data_updt_fifo_dcache_data  = rdata;
     3993
     3994            r_dcache_xtn_flush_data_cpt = r_dcache_xtn_flush_data_cpt + 1;
     3995            if(r_dcache_xtn_flush_data_cpt.read() == (m_dcache_words - 1))
     3996            {
     3997                r_dcache_xtn_flush_data_cpt = 0;
     3998                r_dcache_fsm = DCACHE_XTN_DC_FLUSH_GO;
     3999            }
     4000        }
     4001        break;
     4002    }
     4003
    37704004    ////////////////////////////
    37714005    case DCACHE_XTN_DC_FLUSH_GO:    // Switch the cache slot to ZOMBI state
     
    37764010        size_t set = r_dcache_miss_set.read();
    37774011
    3778         r_dcache_in_tlb[m_dcache_sets*way+set]       = false;
    3779         r_dcache_contains_ptd[m_dcache_sets*way+set] = false;
     4012        // MODIFIED
     4013        //r_dcache_in_tlb[m_dcache_sets*way+set]       = false;
     4014        //r_dcache_contains_ptd[m_dcache_sets*way+set] = false;
     4015        r_dcache_content_state[m_dcache_sets*way+set]  = LINE_CACHE_DATA_DIRTY;
    37804016
    37814017#ifdef INSTRUMENTATION
     
    38204056
    38214057#ifdef INSTRUMENTATION
    3822 m_cpt_dtlb_read++;
     4058m_cpt_data_tlb_read++;
    38234059#endif
    38244060            hit = r_dtlb.translate( r_dcache_save_wdata.read(),
     
    38404076
    38414077#ifdef INSTRUMENTATION
    3842 m_cpt_dtlb_miss++;
     4078m_cpt_data_tlb_miss++;
    38434079#endif
    38444080            r_dcache_tlb_ins    = false;                // dtlb
     
    38774113                           &set,
    38784114                           &word );
    3879 
    3880         if ( state == CACHE_SLOT_STATE_VALID )  // inval to be done
    3881         {
    3882             r_dcache_xtn_way = way;
    3883             r_dcache_xtn_set = set;
    3884             r_dcache_fsm      = DCACHE_XTN_DC_INVAL_GO;
     4115        /*ODCCP*/
     4116        //assert((state != CACHE_SLOT_STATE_VALID_NCC) and "NOT YET DONE");
     4117        if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))      // inval to be done
     4118        {
     4119            r_dcache_xtn_way       = way;
     4120            r_dcache_xtn_set       = set;
     4121            r_dcache_xtn_state     = state;
     4122            r_dcache_xtn_data_addr = r_dcache_save_paddr.read()&~0x3F;
     4123           
     4124            if( (state == CACHE_SLOT_STATE_VALID_NCC) and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY) )
     4125            {
     4126                m_cpt_cleanup_data_not_dirty ++;
     4127            }
     4128            r_dcache_fsm = DCACHE_XTN_DC_INVAL_GO;
     4129           
    38854130        }
    38864131        else            // miss : nothing to do
     
    38964141              << " DCACHE_XTN_DC_INVAL_PA> Test hit in dcache" << std::hex
    38974142              << " / PADDR = " << r_dcache_save_paddr.read() << std::dec
    3898               << " / HIT = " << (state == CACHE_SLOT_STATE_VALID)
     4143              << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))
    38994144              << " / SET = " << set
    39004145              << " / WAY = " << way << std::endl;
     4146    //r_dcache.printTrace();
    39014147}
    39024148#endif
     
    39104156        if ( not r_dcache_cc_send_req.read() ) // blocked until previous cc_send request is sent
    39114157        {
     4158            int     state      = r_dcache_xtn_state.read();
    39124159            size_t      way        = r_dcache_xtn_way.read();
    39134160            size_t      set        = r_dcache_xtn_set.read();
     
    39174164m_cpt_dcache_dir_write++;
    39184165#endif
    3919             r_dcache.write_dir( way,
    3920                                 set,
    3921                                 CACHE_SLOT_STATE_ZOMBI );
    3922 
    3923             // request cleanup
    3924             r_dcache_cc_send_req   = true;
    3925             r_dcache_cc_send_nline = nline;
    3926             r_dcache_cc_send_way   = way;
    3927             r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     4166            // MODIFIER POUR DIRTY BIT //
     4167            if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))// request cleanup
     4168            {
     4169                r_dcache_cc_send_req   = true;
     4170                r_dcache_cc_send_nline = nline;
     4171                r_dcache_cc_send_way   = way;
     4172                r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     4173                if (state == CACHE_SLOT_STATE_VALID_CC)
     4174                {
     4175                    r_dcache_cc_cleanup_line_ncc = false;
     4176                    r_dcache.write_dir( way,
     4177                            set,
     4178                            CACHE_SLOT_STATE_ZOMBI );
     4179                }
     4180                else
     4181                {
     4182                    r_dcache_cc_cleanup_line_ncc = true;
     4183                    //if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY)) //must send data
     4184                    if (true) //must send data
     4185                    {
     4186                        r_dcache_cc_cleanup_updt_data = true;
     4187                        for (size_t w = 0; w< m_dcache_words; w++)
     4188                        {
     4189                            m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     4190                        }
     4191                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_DATA;
     4192                        break;
     4193                    }
     4194                    else
     4195                    {
     4196                        r_dcache_cc_cleanup_updt_data = false;
     4197                        r_dcache.write_dir( way,
     4198                                            set,
     4199                                            CACHE_SLOT_STATE_ZOMBI );
     4200                    }
     4201                    if( (state == CACHE_SLOT_STATE_VALID_NCC) and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY) )
     4202                        m_cpt_cleanup_data_not_dirty ++;
     4203                }
     4204            }
     4205            /*ODCCP*/
    39284206
    39294207            // possible itlb & dtlb invalidate
    3930             if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
     4208            // MODIFIED
     4209            //if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
     4210            //{
     4211            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    39314212            {
    39324213                r_dcache_tlb_inval_line = nline;
     
    39344215                r_dcache_fsm_scan_save  = DCACHE_XTN_DC_INVAL_END;
    39354216                r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
    3936                 r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    3937             }
    3938             else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
     4217                // MODIFIED
     4218                //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     4219                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     4220            }
     4221            // MODIFIED
     4222            //else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
     4223            //{
     4224            else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD)
    39394225            {
    39404226                r_itlb.reset();
    39414227                r_dtlb.reset();
    3942                 r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4228                // MODIFIED
     4229                //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4230                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    39434231                r_dcache_fsm = DCACHE_IDLE;
    39444232                m_drsp.valid = true;
     
    39614249        break;
    39624250    }
     4251
     4252    /*ODCCP*/
     4253    //////////////////////////////
     4254    case DCACHE_XTN_DC_INVAL_DATA:      //A verifier
     4255    {
     4256
     4257        uint32_t rdata;
     4258        size_t   way;
     4259        size_t   set;
     4260        size_t   word;
     4261        r_dcache.read_neutral(r_dcache_xtn_data_addr.read(),
     4262                              &rdata,
     4263                              &way,
     4264                              &set,
     4265                              &word);
     4266        if(r_cc_send_data_fifo.wok())
     4267        {
     4268            r_dcache_xtn_data_addr = r_dcache_xtn_data_addr.read() + 4;
     4269
     4270            cleanup_data_updt_fifo_dcache_put   = true;
     4271            cleanup_data_updt_fifo_dcache_data  = rdata;
     4272
     4273            r_dcache_xtn_data_cpt = r_dcache_xtn_data_cpt.read() + 1;
     4274            if(r_dcache_xtn_data_cpt.read() == (m_dcache_words - 1))
     4275            {
     4276                r_dcache_xtn_state = CACHE_SLOT_STATE_ZOMBI;
     4277                r_dcache_xtn_data_cpt = 0;
     4278                r_dcache_fsm = DCACHE_XTN_DC_INVAL_GO;
     4279                r_dcache.write_dir( way,
     4280                                    set,
     4281                                    CACHE_SLOT_STATE_ZOMBI );
     4282            }
     4283        }
     4284        break;
     4285    }
     4286
    39634287    //////////////////////////////
    39644288    case DCACHE_XTN_DC_INVAL_END:       // send response to processor XTN request
     
    40014325            size_t   set = 0;
    40024326            paddr_t  victim = 0;
     4327            int state;
    40034328
    40044329#ifdef INSTRUMENTATION
     
    40114336                                  &found,
    40124337                                  &cleanup );
     4338            state = r_dcache.get_cache_state(way,set);
    40134339
    40144340            if ( found )
     
    40264352                    r_dcache_cc_send_way   = way;
    40274353                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     4354                    if( (state == CACHE_SLOT_STATE_VALID_NCC) )//and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_DIRTY) )
     4355                    {
     4356                        //MODIFIER POUR DIRTY BIT //
     4357                        r_dcache_cc_cleanup_line_ncc = true;
     4358                        r_dcache_miss_data_addr = (victim*m_dcache_words)*4;
     4359                        //if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY))//must send data
     4360                        if (true)//must send data
     4361                        {
     4362                            r_dcache_cc_cleanup_updt_data = true;
     4363                            for (size_t w = 0; w< m_dcache_words; w++)
     4364                            {
     4365                                m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     4366                            }
     4367                            r_dcache_fsm = DCACHE_MISS_DATA;
     4368                        }
     4369                        else
     4370                        {
     4371                            r_dcache_cc_cleanup_updt_data = false;
     4372                        }
     4373
     4374                        if (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY)
     4375                            m_cpt_cleanup_data_not_dirty ++;
     4376                    }
     4377                       
     4378                    else
     4379                    {
     4380                        r_dcache_cc_cleanup_line_ncc  = false;
     4381                        r_dcache_cc_cleanup_updt_data = false;
     4382                    }
    40284383                }
    40294384                else
     
    40494404    }
    40504405    ///////////////////////
     4406    case DCACHE_MISS_DATA:
     4407    {
     4408        uint32_t rdata;
     4409        size_t way;
     4410        size_t set;
     4411        size_t word;
     4412
     4413        r_dcache.read_neutral(r_dcache_miss_data_addr,
     4414                              &rdata,
     4415                              &way,
     4416                              &set,
     4417                              &word);
     4418        if(r_cc_send_data_fifo.wok())
     4419        {
     4420            r_dcache_miss_data_addr = r_dcache_miss_data_addr.read() + 4;
     4421
     4422            cleanup_data_updt_fifo_dcache_put   = true;
     4423            cleanup_data_updt_fifo_dcache_data  = rdata;
     4424
     4425            r_dcache_miss_data_cpt = r_dcache_miss_data_cpt.read() + 1;
     4426            if (r_dcache_miss_data_cpt.read() == m_dcache_words-1 )
     4427            {
     4428                r_dcache_miss_data_cpt = 0;
     4429                r_dcache_fsm = DCACHE_MISS_CLEAN;
     4430            }
     4431        }
     4432        break;
     4433    }
     4434    ///////////////////////
    40514435    case DCACHE_MISS_CLEAN:             // switch the slot to ZOMBI state
    40524436                                // and possibly request itlb or dtlb invalidate
     
    40744458        // if selective itlb & dtlb invalidate are required
    40754459        // the miss response is not handled before invalidate completed
    4076         if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
    4077         {
    4078             r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     4460        // MODIFIED
     4461        //if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
     4462        //{
     4463        if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
     4464        {
     4465            //MODIFIED
     4466            //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     4467            r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    40794468            r_dcache_tlb_inval_line  = r_dcache_cc_send_nline;
    40804469            r_dcache_tlb_inval_set   = 0;
     
    40824471            r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    40834472        }
    4084         else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
     4473        // MODIFIED
     4474        //else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
     4475        //{
     4476        else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
    40854477        {
    40864478            r_itlb.reset();
    40874479            r_dtlb.reset();
    4088             r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4480            // MODIFIED
     4481            //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4482            r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    40894483            r_dcache_fsm = DCACHE_MISS_WAIT;
    40904484        }
     
    41014495    {
    41024496        if ( m_dreq.valid) m_cost_data_miss_frz++;
    4103 
    41044497        // coherence clack request (from DSPIN CLACK)
    41054498        if ( r_dcache_clack_req.read() )
     
    41844577        if ( m_dreq.valid) m_cost_data_miss_frz++;
    41854578
    4186         if ( r_vci_rsp_fifo_dcache.rok() )      // one word available
     4579        if ( r_vci_rsp_fifo_dcache.rok() && r_vci_rsp_fifo_rpktid.rok())        // one word available
    41874580        {
    41884581#ifdef INSTRUMENTATION
     
    42054598#endif
    42064599            vci_rsp_fifo_dcache_get = true;
     4600
     4601            r_dcache_read_state = !r_vci_rsp_fifo_rpktid.read();//deduce the state (CC or NCC) from msb of pktid
     4602            vci_rsp_fifo_rpktid_get = true;
     4603
     4604
    42074605            r_dcache_miss_word = r_dcache_miss_word.read() + 1;
    42084606
     
    42534651                    r_dcache_cc_send_way   = r_dcache_miss_way.read();
    42544652                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     4653                    r_dcache_cc_cleanup_updt_data = false; //the line is evicted at the very moment it arives, so it is not dirty
     4654                    r_dcache_cc_cleanup_line_ncc = !r_dcache_read_state.read();
    42554655
    42564656#ifdef INSTRUMENTATION
     
    42794679m_cpt_dcache_dir_write++;
    42804680#endif
    4281                 r_dcache.write_dir( r_dcache_save_paddr.read(),
    4282                                     r_dcache_miss_way.read(),
    4283                                     r_dcache_miss_set.read(),
    4284                                     CACHE_SLOT_STATE_VALID );
     4681
     4682                size_t way = r_dcache_miss_way.read();
     4683                size_t set = r_dcache_miss_set.read();
     4684                if (r_dcache_read_state.read())
     4685                {
     4686                  r_dcache.write_dir( r_dcache_save_paddr.read(),
     4687                                        r_dcache_miss_way.read(),
     4688                                        r_dcache_miss_set.read(),
     4689                                        CACHE_SLOT_STATE_VALID_CC );
     4690
     4691                    r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     4692                }
     4693                else
     4694                {
     4695                  r_dcache.write_dir( r_dcache_save_paddr.read(),
     4696                                        r_dcache_miss_way.read(),
     4697                                        r_dcache_miss_set.read(),
     4698                                        CACHE_SLOT_STATE_VALID_NCC );
     4699                    r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     4700                    for (size_t word =0; word < m_dcache_words ; word++)
     4701                    {
     4702                        r_dcache_dirty_word[(way*m_dcache_sets +set)*m_dcache_words+word] = 0;
     4703                    }
     4704                }
    42854705
    42864706#if DEBUG_DCACHE
     
    42934713#endif
    42944714                // reset directory extension
    4295                 size_t way = r_dcache_miss_way.read();
    4296                 size_t set = r_dcache_miss_set.read();
    4297                 r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4298                 r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4715
     4716                // MODIFIED
     4717                //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     4718                //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    42994719            }
    43004720            if      (r_dcache_miss_type.read()==PTE1_MISS) r_dcache_fsm = DCACHE_TLB_PTE1_GET;
     
    44674887                       &state );
    44684888
    4469         assert( (state == CACHE_SLOT_STATE_VALID) and
     4889        assert( (state == CACHE_SLOT_STATE_VALID_CC or state == CACHE_SLOT_STATE_VALID_NCC) and
    44704890        "error in DCACHE_DIRTY_TLB_SET: the PTE should be in dcache" );
    44714891
     
    44794899
    44804900        // request a CAS CMD and go to DCACHE_DIRTY_WAIT state
    4481         r_dcache_vci_cas_req = true;
    4482         r_dcache_vci_paddr   = r_dcache_dirty_paddr.read();
    4483         r_dcache_vci_cas_old = pte;
    4484         r_dcache_vci_cas_new = pte | PTE_D_MASK;
    4485         r_dcache_fsm         = DCACHE_DIRTY_WAIT;
     4901        if (state == CACHE_SLOT_STATE_VALID_CC)
     4902        {
     4903            r_dcache_vci_cas_req = true;
     4904            r_dcache_vci_paddr   = r_dcache_dirty_paddr.read();
     4905            r_dcache_vci_cas_old = pte;
     4906            r_dcache_vci_cas_new = pte | PTE_D_MASK;
     4907            r_cas_islocal        = false;
     4908        }
     4909        else
     4910        {
     4911            r_cas_islocal = true;
     4912            r_cas_local_way = way;
     4913            r_cas_local_set = set;
     4914            r_cas_local_word = word;
     4915            r_dcache_vci_cas_new = pte | PTE_D_MASK;
     4916        }
     4917
     4918
     4919            r_dcache_fsm         = DCACHE_DIRTY_WAIT;
    44864920
    44874921#if DEBUG_DCACHE
     
    45064940                                    // - if the CAS is a failure, we just retry the write.
    45074941    {
     4942        uint32_t way  = r_cas_local_way.read();
     4943        uint32_t set  = r_cas_local_set.read();
     4944        uint32_t word = r_cas_local_word.read();
     4945        paddr_t nline = r_dcache_dirty_paddr.read() / (m_dcache_words<<2);
     4946
    45084947        // coherence clack request (from DSPIN CLACK)
    45094948        if ( r_dcache_clack_req.read() )
     
    45224961        }
    45234962
    4524         if ( r_vci_rsp_data_error.read() )      // bus error
    4525         {
    4526             std::cout << "BUS ERROR in DCACHE_DIRTY_WAIT state" << std::endl;
    4527             std::cout << "This should not happen in this state" << std::endl;
    4528             exit(0);
    4529         }
    4530         else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
    4531         {
    4532             vci_rsp_fifo_dcache_get = true;
    4533             r_dcache_fsm            = DCACHE_IDLE;
    4534 
     4963        if (!r_cas_islocal.read())
     4964        {
     4965            if ( r_vci_rsp_data_error.read() )  // bus error
     4966            {
     4967                std::cout << "BUS ERROR in DCACHE_DIRTY_WAIT state" << std::endl;
     4968                std::cout << "This should not happen in this state" << std::endl;
     4969                exit(0);
     4970            }
     4971            else if ( r_vci_rsp_fifo_dcache.rok() )     // response available
     4972            {
     4973                vci_rsp_fifo_dcache_get = true;
     4974                r_dcache_fsm            = DCACHE_IDLE;
    45354975#if DEBUG_DCACHE
    45364976if ( m_debug_activated )
     
    45404980}
    45414981#endif
     4982            }
     4983        }
     4984        else
     4985        {
     4986            r_dcache.write(way,
     4987                           set,
     4988                           word,
     4989                           r_dcache_vci_cas_new.read());
     4990            //std::cout << "CAS local" << std::endl;
     4991            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
     4992            {
     4993                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     4994                r_dcache_tlb_inval_line  = nline;
     4995                r_dcache_tlb_inval_set   = 0;
     4996                r_dcache_fsm_scan_save   = DCACHE_IDLE;
     4997                r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     4998                break;
     4999            }
     5000
     5001            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     5002            {
     5003                r_itlb.reset();
     5004                r_dtlb.reset();
     5005                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     5006
     5007#if DEBUG_DCACHE
     5008                if ( m_debug_activated )
     5009                {
     5010                    std::cout << "  <PROC " << name()
     5011                        << " DCACHE_DIRTY_WAIT> Flush DTLB & ITLB" << std::endl;
     5012                }
     5013#endif
     5014            }
     5015            r_dcache_fsm            = DCACHE_IDLE;
    45425016        }
    45435017        break;
     
    46745148                           &word ); // unused
    46755149
     5150        r_dcache_cc_state = state;
    46765151        r_dcache_cc_way = way;
    46775152        r_dcache_cc_set = set;
    4678 
    4679         if ( state == CACHE_SLOT_STATE_VALID) // hit
    4680         {
    4681             // need to update the cache state
    4682             if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT) // hit update
    4683             {
    4684                 r_dcache_cc_need_write = true;
    4685                 r_dcache_fsm           = DCACHE_CC_UPDT;
    4686                 r_dcache_cc_word       = r_cc_receive_word_idx.read();
    4687             }
    4688             else if ( r_cc_receive_dcache_type.read() == CC_TYPE_INVAL ) // hit inval
    4689             {
    4690                 r_dcache_fsm           = DCACHE_CC_INVAL;
     5153            /*RWT / ODCCP*/
     5154        if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))             // hit
     5155        {
     5156          // need to update the cache state
     5157            r_dcache_cc_need_write = true;
     5158            r_dcache_cc_cleanup_line_ncc = false;
     5159            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)  // hit update
     5160            {
     5161                r_dcache_fsm          = DCACHE_CC_UPDT;
     5162                r_dcache_cc_word      = r_cc_receive_word_idx.read();
     5163            }
     5164            else if (r_cc_receive_dcache_type.read() == CC_TYPE_INVAL)   // hit inval
     5165            {
     5166                if (state == CACHE_SLOT_STATE_VALID_NCC)
     5167                {
     5168                    r_dcache_cc_inval_addr = (paddr &~0x3F);
     5169                    r_dcache_cc_inval_data_cpt = 0;
     5170                }
     5171                r_dcache_fsm          = DCACHE_CC_INVAL;
     5172                r_dcache_dirty_save   = false;
    46915173            }
    46925174        }
     
    47165198              << " PADDR = " << std::hex << paddr
    47175199              << " / TYPE = " << std::dec << r_cc_receive_dcache_type.read()
    4718               << " / HIT = " << (state == CACHE_SLOT_STATE_VALID) << std::endl;
     5200              << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) << std::endl;
    47195201}
    47205202#endif
     
    47225204        break;
    47235205    }
     5206
    47245207    /////////////////////
    47255208    case DCACHE_CC_INVAL: // hit inval: switch slot to ZOMBI state and send a
     
    47295212        size_t way    = r_dcache_cc_way.read();
    47305213        size_t set    = r_dcache_cc_set.read();
    4731 
    4732         if ( r_dcache_in_tlb[way*m_dcache_sets+set] )       // selective TLB inval
    4733         {
    4734             r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4735             r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
    4736             r_dcache_tlb_inval_set   = 0;
    4737             r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    4738             r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    4739             break;
    4740         }
    4741 
    4742         if ( r_dcache_contains_ptd[way*m_dcache_sets+set] ) // TLB flush
    4743         {
    4744             r_itlb.reset();
    4745             r_dtlb.reset();
    4746             r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    4747 
     5214        int      cache_state = r_dcache_cc_state.read();
     5215        bool     dirty_save = false;
     5216
     5217        if (r_dcache_cc_need_write.read())
     5218        {
     5219            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
     5220            {
     5221                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;//need to remember it was dirty for cleanup
     5222                dirty_save = true;
     5223                r_dcache_dirty_save = true;
     5224                r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
     5225                r_dcache_tlb_inval_set   = 0;
     5226                r_dcache_fsm_scan_save   = r_dcache_fsm.read();
     5227                r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     5228                break;
     5229            }
     5230            else
     5231            {
     5232                if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     5233                {
     5234                    r_itlb.reset();
     5235                    r_dtlb.reset();
     5236                    r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     5237                    dirty_save = true;
     5238                    r_dcache_dirty_save = true;
    47485239#if DEBUG_DCACHE
    47495240if ( m_debug_activated )
     
    47535244}
    47545245#endif
    4755         }
    4756 
    4757         assert (not r_dcache_cc_send_req.read() &&
    4758                 "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    4759                 "must not be set");
    4760 
    4761         // Switch slot state to ZOMBI and send CLEANUP command
    4762         r_dcache.write_dir( 0,
    4763                             way,
    4764                             set,
    4765                             CACHE_SLOT_STATE_ZOMBI );
    4766 
    4767         // coherence request completed
    4768         r_cc_receive_dcache_req = false;
    4769         r_dcache_cc_send_req    = true;
    4770         r_dcache_cc_send_nline  = r_cc_receive_dcache_nline.read();
    4771         r_dcache_cc_send_way    = r_dcache_cc_way.read();
    4772         r_dcache_cc_send_type   = CC_TYPE_CLEANUP;
    4773         r_dcache_fsm            = r_dcache_fsm_cc_save.read();
    4774 
    4775 #if DEBUG_DCACHE
    4776 if ( m_debug_activated )
    4777 {
    4778     std::cout << "  <PROC " << name()
    4779         << " DCACHE_CC_INVAL> Switch slot to EMPTY state:" << std::dec
    4780         << " / WAY = " << way
    4781         << " / SET = " << set << std::endl;
    4782 }
    4783 #endif
     5246                }
     5247
     5248                if (cache_state == CACHE_SLOT_STATE_VALID_CC)
     5249                {
     5250                    r_dcache.write_dir( way,
     5251                                        set,
     5252                                        CACHE_SLOT_STATE_ZOMBI );
     5253                }
     5254
     5255                r_dcache_cc_need_write = false;
     5256            }
     5257        }
     5258            assert (not r_dcache_cc_send_req.read() &&
     5259                    "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
     5260                    "must not be set");
     5261            // coherence request completed
     5262                r_cc_receive_dcache_req = false;
     5263            // request multicast acknowledgement
     5264                r_dcache_cc_send_req = true;
     5265                r_dcache_cc_send_way = way;
     5266                r_dcache_cc_send_nline = r_cc_receive_dcache_nline.read();
     5267                r_dcache_cc_send_type = CC_TYPE_CLEANUP;
     5268                // MODIFIER POUR DIRTY BIT //
     5269                if (cache_state == CACHE_SLOT_STATE_VALID_NCC)
     5270                {
     5271                    r_dcache_cc_cleanup_line_ncc = true;
     5272                    //if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY) or r_dcache_dirty_save.read() or dirty_save) //must send data
     5273                    if (true) //must send data
     5274                    {
     5275                        r_dcache_cc_cleanup_updt_data = true;
     5276                        for (size_t w = 0; w< m_dcache_words; w++)
     5277                        {
     5278                            m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     5279                        }
     5280                        r_dcache_fsm          = DCACHE_CC_INVAL_DATA;
     5281                    }
     5282                    else
     5283                    {
     5284                        r_dcache_cc_cleanup_updt_data = false;
     5285                        r_dcache_fsm = r_dcache_fsm_cc_save.read();
     5286                    }
     5287                }
     5288                else
     5289                {
     5290                    r_dcache_cc_cleanup_updt_data = false;
     5291                    r_dcache_fsm = r_dcache_fsm_cc_save.read();
     5292                }
     5293
     5294        break;
     5295    }
     5296   
     5297    /////////////////////
     5298    case DCACHE_CC_INVAL_DATA:
     5299    {
     5300
     5301        uint32_t rdata;
     5302        size_t   way;
     5303        size_t   set;
     5304        size_t   word;
     5305        r_dcache.read_neutral(r_dcache_cc_inval_addr.read(),
     5306                              &rdata,
     5307                              &way,
     5308                              &set,
     5309                              &word);
     5310        if(r_cc_send_data_fifo.wok())
     5311        {
     5312            r_dcache_cc_inval_addr = r_dcache_cc_inval_addr.read() + 4;
     5313
     5314            cleanup_data_updt_fifo_dcache_put   = true;
     5315            cleanup_data_updt_fifo_dcache_data  = rdata;
     5316
     5317            r_dcache_cc_inval_data_cpt = r_dcache_cc_inval_data_cpt.read() + 1;
     5318            if(r_dcache_cc_inval_data_cpt.read() == (m_dcache_words - 1))
     5319            {
     5320                r_dcache_cc_inval_data_cpt = 0;
     5321                r_dcache_fsm          = r_dcache_fsm_cc_save.read();
     5322                r_dcache.write_dir( way,
     5323                                    set,
     5324                                    CACHE_SLOT_STATE_ZOMBI );
     5325            }
     5326        }
    47845327        break;
    47855328    }
     
    47925335        size_t set        = r_dcache_cc_set.read();
    47935336
    4794         if ( r_dcache_in_tlb[way*m_dcache_sets+set] )       // selective TLB inval
    4795         {
    4796             r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4797             r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
    4798             r_dcache_tlb_inval_set  = 0;
    4799             r_dcache_fsm_scan_save  = r_dcache_fsm.read();
    4800             r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
    4801 
    4802             break;
    4803         }
    4804 
    4805         if ( r_dcache_contains_ptd[way*m_dcache_sets+set] ) // TLB flush
    4806         {
    4807             r_itlb.reset();
    4808             r_dtlb.reset();
    4809             r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     5337            if (r_dcache_cc_need_write.read())
     5338            {
     5339                if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
     5340                {
     5341                    r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     5342                    r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
     5343                    r_dcache_tlb_inval_set   = 0;
     5344                    r_dcache_fsm_scan_save   = r_dcache_fsm.read();
     5345                    r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     5346                    break;
     5347                }
     5348                if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     5349                {
     5350                    r_itlb.reset();
     5351                    r_dtlb.reset();
     5352                    r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
    48105353
    48115354#if DEBUG_DCACHE
     
    48165359}
    48175360#endif
    4818         }
    4819 
    4820         assert (not r_dcache_cc_send_req.read() &&
    4821                 "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    4822                 "must not be set");
     5361                }
     5362
     5363                assert (not r_dcache_cc_send_req.read() &&
     5364                        "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
     5365                        "must not be set");
    48235366       
    4824         if ( not r_cc_receive_updt_fifo_be.rok() ) break;
    4825 
    4826         if (r_dcache_cc_need_write.read())
    4827         {
    4828        
     5367                if ( not r_cc_receive_updt_fifo_be.rok() ) break;
     5368
    48295369#ifdef INSTRUMENTATION
    48305370m_cpt_dcache_data_write++;
     
    48555395            // no need to write in the cache anymore
    48565396            r_dcache_cc_need_write = false;
    4857 
    48585397            // coherence request completed
    48595398            r_cc_receive_dcache_req = false;
     
    50415580                        r_dcache_vci_unc_req.read())
    50425581                     or r_vci_cmd_imiss_prio.read() );
    5043 
    50445582            // 1 - Data Read Miss
    50455583            if ( dcache_miss_req and r_wbuf.miss(r_dcache_vci_paddr.read()) )
     
    50485586                r_dcache_vci_miss_req = false;
    50495587                r_vci_cmd_imiss_prio  = true;
    5050 //                m_cpt_dmiss_transaction++;
     5588                m_cpt_dmiss_transaction++;
    50515589            }
    50525590            // 2 - Data Read Uncachable
     
    50555593                r_vci_cmd_fsm        = CMD_DATA_UNC;
    50565594                r_dcache_vci_unc_req = false;
    5057 //                m_cpt_dunc_transaction++;
     5595                m_cpt_dunc_transaction++;
    50585596            }
    50595597            // 3 - Data Linked Load
     
    50625600                r_dcache_vci_ll_req = false;
    50635601                r_vci_cmd_fsm       = CMD_DATA_LL;
    5064 //              m_cpt_ll_transaction++;
     5602                m_cpt_ll_transaction++;
    50655603            }
    50665604            // 4 - Instruction Miss
     
    50705608                r_icache_miss_req    = false;
    50715609                r_vci_cmd_imiss_prio = false;
    5072 //                m_cpt_imiss_transaction++;
     5610                m_cpt_imiss_transaction++;
    50735611            }
    50745612            // 5 - Instruction Uncachable
     
    50775615                r_vci_cmd_fsm       = CMD_INS_UNC;
    50785616                r_icache_unc_req    = false;
    5079 //                m_cpt_iunc_transaction++;
     5617                //m_cpt_iunc_transaction++;
    50805618            }
    50815619            // 6 - Data Write
     
    50865624                r_vci_cmd_min       = wbuf_min;
    50875625                r_vci_cmd_max       = wbuf_max;
    5088 //                m_cpt_write_transaction++;
    5089 //                m_length_write_transaction += (wbuf_max-wbuf_min+1);
     5626                m_cpt_write_transaction++;
     5627                m_length_write_transaction += (wbuf_max-wbuf_min+1);
    50905628            }
    50915629            // 7 - Data Store Conditionnal
     
    50955633                r_vci_cmd_cpt  = 0;
    50965634                r_vci_cmd_fsm  = CMD_DATA_SC;
    5097 //              m_cpt_sc_transaction++;
     5635                //m_cpt_sc_transaction++;
    50985636            }
    50995637            // 8 - Compare And Swap
     
    51035641                r_dcache_vci_cas_req = false;
    51045642                r_vci_cmd_cpt        = 0;
    5105 //              m_cpt_cas_transaction++;
     5643                //m_cpt_cas_transaction++;
    51065644            }
    51075645
     
    51945732        {
    51955733            r_vci_rsp_cpt = 0;
    5196 
     5734            if (r_dcache_vci_paddr.read() == 0x1f624) std::cout << "Tansaction on barrier, pktid = " <<  p_vci.rpktid.read() << std::endl;
    51975735            if      ( (p_vci.rpktid.read() & 0x7) ==  TYPE_READ_DATA_UNC  )
    51985736            {
     
    53115849                else                                        // no error reported
    53125850                {
    5313                     if ( r_vci_rsp_fifo_dcache.wok() )
     5851
     5852
     5853                    if ( r_vci_rsp_fifo_dcache.wok() && r_vci_rsp_fifo_rpktid.wok())
    53145854                    {
    53155855                        assert( (r_vci_rsp_cpt.read() < m_dcache_words) and
     
    53195859                        vci_rsp_fifo_dcache_put       = true,
    53205860                        vci_rsp_fifo_dcache_data      = p_vci.rdata.read();
     5861                        vci_rsp_fifo_rpktid          = (p_vci.rpktid.read() == 0x9);//RWT: interpretation of pktid for state (NCC or CC)
     5862                        vci_rsp_fifo_rpktid_put      = true;//RWT
     5863
    53215864                        if ( p_vci.reop.read() )
    53225865                        {
     5866                            if (r_vci_rsp_cpt.read() != m_dcache_words - 1) std::cout << "assert on proc " << name() << std::endl;
    53235867                            assert( (r_vci_rsp_cpt.read() == m_dcache_words - 1) and
    53245868                            "The VCI response packet for data miss is too short");
     
    54806024            if (p_dspin_p2m.read.read())
    54816025            {
    5482                 if (r_cc_send_last_client.read() == 0) // dcache active request
    5483                     r_dcache_cc_send_req = false; // reset dcache request
    5484                 else // icache active request
    5485                     r_icache_cc_send_req = false; // reset icache request
    5486 
    5487                 // go back to idle state
    5488                 r_cc_send_fsm = CC_SEND_IDLE;
     6026                //std::cout << "CLEANUP send on line " << r_dcache_cc_send_nline.read() << std::endl;
     6027                if(r_dcache_cc_cleanup_updt_data.read() and (r_cc_send_last_client.read() == 0))//dcache request with data
     6028               {
     6029                    r_cc_send_fsm = CC_SEND_CLEANUP_DATA_UPDT;
     6030                }
     6031                else
     6032                {
     6033                    if (r_cc_send_last_client.read() == 0) // dcache active request
     6034                    {
     6035                        r_dcache_cc_send_req = false; // reset dcache request
     6036                    }
     6037                    else // icache active request
     6038                    {
     6039                        r_icache_cc_send_req = false; // reset icache request
     6040                    }
     6041                    // go back to idle state
     6042                    r_cc_send_fsm = CC_SEND_IDLE;
     6043                }
     6044            }
     6045            break;
     6046        }
     6047        ///////////////////////////
     6048        case CC_SEND_CLEANUP_DATA_UPDT:
     6049        {
     6050            if (p_dspin_p2m.read.read())
     6051            {
     6052                if(r_cc_send_data_fifo.rok())
     6053                {
     6054                    /*ODCCP*///std::cout<<"CLEANUP_DATA_UPDT" << std::endl;
     6055                    m_cpt_data_cleanup++;
     6056                    cleanup_data_updt_fifo_dcache_get = true;
     6057                    r_cc_send_cpt_word = r_cc_send_cpt_word.read() + 1;
     6058                    if (r_cc_send_cpt_word.read() == m_dcache_words-1)
     6059                    {
     6060                        //std::cout << "L1 paddr CLEANUP DATA | paddr = " << std::hex << (r_dcache_cc_send_nline.read()*m_dcache_words)*4 << std::dec << std::endl;
     6061                        /*ODCCP*/
     6062                        //std::cout << "CLEANUP with DATA finished by " << name() << std::endl;
     6063                        r_dcache_cc_send_req = false;
     6064                        r_dcache_cc_cleanup_updt_data = false;
     6065                        r_cc_send_cpt_word = 0;
     6066                        r_cc_send_fsm = CC_SEND_IDLE;
     6067                    }
     6068                }
    54896069            }
    54906070            break;
     
    58016381                                 vci_rsp_fifo_dcache_put,
    58026382                                 vci_rsp_fifo_dcache_data);
     6383    //BUG pktid
     6384    r_vci_rsp_fifo_rpktid.update(vci_rsp_fifo_rpktid_get,
     6385                                 vci_rsp_fifo_rpktid_put,
     6386                                 vci_rsp_fifo_rpktid);
     6387
     6388    r_cc_send_data_fifo.update(cleanup_data_updt_fifo_dcache_get,
     6389                               cleanup_data_updt_fifo_dcache_put,
     6390                               cleanup_data_updt_fifo_dcache_data);
    58036391
    58046392    ///////////////// updt FIFO update  //////////////////////
     
    60116599                                >> (m_nline_width - m_x_width - m_y_width)
    60126600                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6013  
    60146601                DspinDhccpParam::dspin_set(dspin_send_data,
    60156602                                           dest,
     
    60276614                                           DspinDhccpParam::TYPE_CLEANUP_DATA,
    60286615                                           DspinDhccpParam::P2M_TYPE);
     6616
     6617                DspinDhccpParam::dspin_set(dspin_send_data,
     6618                                           (r_dcache_cc_cleanup_line_ncc.read() and (r_cc_send_last_client.read() == 0)),
     6619                                           DspinDhccpParam::CLEANUP_NCC);
    60296620            }
    60306621            else                                // icache active request
     
    60496640                                           DspinDhccpParam::TYPE_CLEANUP_INST,
    60506641                                           DspinDhccpParam::P2M_TYPE);
     6642
     6643                DspinDhccpParam::dspin_set(dspin_send_data,
     6644                                           0,
     6645                                           DspinDhccpParam::CLEANUP_NCC);
     6646
     6647
    60516648            }
    60526649            // send flit
     
    60606657        {
    60616658            // initialize dspin send data
    6062 //            DspinDhccpParam::dspin_set(dspin_send_data,
    6063 //                                       1,
    6064 //                                       DspinDhccpParam::P2M_EOP);
    6065 
    60666659            if(r_cc_send_last_client.read() == 0) // dcache active request
    60676660            {
     
    60796672            p_dspin_p2m.data  = dspin_send_data;
    60806673            p_dspin_p2m.write = true;
    6081             p_dspin_p2m.eop   = true;
     6674            p_dspin_p2m.eop   = ! (r_dcache_cc_cleanup_updt_data.read() and (r_cc_send_last_client.read() == 0));
     6675            break;
     6676        }
     6677        ///////////////////////
     6678        case CC_SEND_CLEANUP_DATA_UPDT:
     6679        {
     6680            /*if (r_cc_send_cpt_word.read() == m_dcache_words-1)
     6681            {
     6682                DspinDhccpParam::dspin_set(dspin_send_data,
     6683                                           1,
     6684                                           DspinDhccpParam::FROM_L1_EOP);
     6685            }
     6686            else
     6687            {
     6688                DspinDhccpParam::dspin_set(dspin_send_data,
     6689                                           0,
     6690                                           DspinDhccpParam::FROM_L1_EOP);
     6691            }*/
     6692
     6693            DspinDhccpParam::dspin_set(dspin_send_data,
     6694                                       r_cc_send_data_fifo.read(),
     6695                                       DspinDhccpParam::CLEANUP_DATA_UPDT);
     6696           
     6697            p_dspin_p2m.data = dspin_send_data;
     6698            //std::cout << "genmoore CLEANUP DATA UPDT : dspin_send_data = " << std::hex << dspin_send_data << std::dec << std::endl;
     6699            p_dspin_p2m.write = true;
     6700            p_dspin_p2m.eop = (r_cc_send_cpt_word.read() == m_dcache_words-1);
    60826701            break;
    60836702        }
  • branches/RWT/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

    r449 r477  
    9696
    9797    bool    valid;                  // entry valid
     98    bool    cache_coherent;         // WB or WT policy
    9899    bool    is_cnt;                 // directory entry is in counter mode
    99100    bool    dirty;                  // entry dirty
     
    107108    {
    108109      valid         = false;
     110      cache_coherent= false;
    109111      is_cnt        = false;
    110112      dirty         = false;
     
    123125    {
    124126      valid         = source.valid;
     127      cache_coherent= source.cache_coherent;
    125128      is_cnt        = source.is_cnt;
    126129      dirty         = source.dirty;
     
    138141    {
    139142      valid     = false;
     143      cache_coherent = false;
    140144      is_cnt    = false;
    141145      dirty     = false;
     
    150154    {
    151155      valid         = source.valid;
     156      cache_coherent = source.cache_coherent;
    152157      is_cnt    = source.is_cnt;
    153158      dirty         = source.dirty;
     
    165170    {
    166171      std::cout << "Valid = " << valid
     172                << " ; COHERENCE = " << cache_coherent
    167173                << " ; IS COUNT = " << is_cnt
    168174                << " ; Dirty = " << dirty
  • branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r468 r477  
    131131        CC_SEND_XRAM_RSP_INVAL_HEADER,
    132132        CC_SEND_XRAM_RSP_INVAL_NLINE,
     133        CC_SEND_READ_NCC_INVAL_HEADER,
     134        CC_SEND_READ_NCC_INVAL_NLINE,
     135        CC_SEND_WRITE_NCC_INVAL_HEADER,
     136        CC_SEND_WRITE_NCC_INVAL_NLINE,
    133137        CC_SEND_WRITE_BRDCAST_HEADER,
    134138        CC_SEND_WRITE_BRDCAST_NLINE,
     
    178182        READ_DIR_REQ,
    179183        READ_DIR_LOCK,
     184        READ_IVT_LOCK,
     185        READ_WAIT,
    180186        READ_DIR_HIT,
    181187        READ_HEAP_REQ,
     
    197203        WRITE_DIR_REQ,
    198204        WRITE_DIR_LOCK,
     205        WRITE_IVT_LOCK_HIT_WB,
    199206        WRITE_DIR_READ,
    200207        WRITE_DIR_HIT,
     
    205212        WRITE_UPT_DEC,
    206213        WRITE_RSP,
     214        WRITE_MISS_IVT_LOCK,
    207215        WRITE_MISS_TRT_LOCK,
    208216        WRITE_MISS_TRT_DATA,
     
    253261        IXR_CMD_CAS_IDLE,
    254262        IXR_CMD_XRAM_IDLE,
     263        IXR_CMD_CLEANUP_IDLE,
    255264        IXR_CMD_READ,
    256265        IXR_CMD_WRITE,
    257266        IXR_CMD_CAS,
    258         IXR_CMD_XRAM
     267        IXR_CMD_XRAM,
     268        IXR_CMD_CLEANUP_DATA
    259269      };
    260270
     
    290300        CLEANUP_IDLE,
    291301        CLEANUP_GET_NLINE,
     302        CLEANUP_GET_DATA,
    292303        CLEANUP_DIR_REQ,
    293304        CLEANUP_DIR_LOCK,
    294305        CLEANUP_DIR_WRITE,
     306        CLEANUP_IVT_LOCK_DATA,
     307        CLEANUP_IVT_CLEAR_DATA,
     308        CLEANUP_READ_RSP,
    295309        CLEANUP_HEAP_REQ,
    296310        CLEANUP_HEAP_LOCK,
     
    302316        CLEANUP_IVT_CLEAR,
    303317        CLEANUP_WRITE_RSP,
     318        CLEANUP_IXR_REQ,
     319        CLEANUP_WAIT,
    304320        CLEANUP_CONFIG_ACK,
    305321        CLEANUP_SEND_CLACK
     
    325341        ALLOC_TRT_CAS,
    326342        ALLOC_TRT_XRAM_RSP,
    327         ALLOC_TRT_IXR_RSP
     343        ALLOC_TRT_IXR_RSP,
     344        ALLOC_TRT_CLEANUP
    328345      };
    329346
     
    340357      {
    341358        ALLOC_IVT_WRITE,
     359        ALLOC_IVT_READ,
    342360        ALLOC_IVT_XRAM_RSP,
    343361        ALLOC_IVT_CLEANUP,
     
    434452      uint32_t     m_cpt_sc;            // Number of SC transactions
    435453      uint32_t     m_cpt_cas;           // Number of CAS transactions
     454     
     455      uint32_t     m_cpt_read_fsm_dir_lock;        // wait DIR LOCK
     456      uint32_t     m_cpt_read_fsm_n_dir_lock;      // NB DIR LOCK
     457      uint32_t     m_cpt_write_fsm_dir_lock;       // wait DIR LOCK
     458      uint32_t     m_cpt_write_fsm_n_dir_lock;     // NB DIR LOCK
     459      uint32_t     m_cpt_xram_rsp_fsm_dir_lock;    // wait DIR LOCK
     460      uint32_t     m_cpt_xram_rsp_fsm_n_dir_lock;  // NB DIR LOCK
     461      uint32_t     m_cpt_cas_fsm_dir_lock;         // wait DIR LOCK
     462      uint32_t     m_cpt_cas_fsm_n_dir_lock;       // NB DIR LOCK
     463      uint32_t     m_cpt_cleanup_fsm_dir_lock;     // wait DIR LOCK
     464      uint32_t     m_cpt_cleanup_fsm_n_dir_lock;   // NB DIR LOCK
     465     
     466      uint32_t     m_cpt_dir_unused;            // NB cycles DIR LOCK unused
     467      uint32_t     m_cpt_read_fsm_dir_used;     // NB cycles DIR LOCK used
     468      uint32_t     m_cpt_write_fsm_dir_used;    // NB cycles DIR LOCK used
     469      uint32_t     m_cpt_cas_fsm_dir_used;      // NB cycles DIR LOCK used
     470      uint32_t     m_cpt_xram_rsp_fsm_dir_used; // NB cycles DIR LOCK used
     471      uint32_t     m_cpt_cleanup_fsm_dir_used;  // NB cycles DIR LOCK used
     472
     473      uint32_t     m_cpt_read_fsm_trt_lock;      // wait TRT LOCK
     474      uint32_t     m_cpt_write_fsm_trt_lock;     // wait TRT LOCK
     475      uint32_t     m_cpt_cas_fsm_trt_lock;       // wait TRT LOCK
     476      uint32_t     m_cpt_xram_rsp_fsm_trt_lock;  // wait TRT LOCK
     477      uint32_t     m_cpt_ixr_fsm_trt_lock;       // wait TRT LOCK
     478     
     479      uint32_t     m_cpt_read_fsm_n_trt_lock;      // NB TRT LOCK
     480      uint32_t     m_cpt_write_fsm_n_trt_lock;     // NB TRT LOCK
     481      uint32_t     m_cpt_cas_fsm_n_trt_lock;       // NB TRT LOCK
     482      uint32_t     m_cpt_xram_rsp_fsm_n_trt_lock;  // NB TRT LOCK
     483      uint32_t     m_cpt_ixr_fsm_n_trt_lock;       // NB TRT LOCK
     484
     485      uint32_t     m_cpt_read_fsm_trt_used;      // NB cycles TRT LOCK used
     486      uint32_t     m_cpt_write_fsm_trt_used;     // NB cycles TRT LOCK used
     487      uint32_t     m_cpt_cas_fsm_trt_used;       // NB cycles TRT LOCK used
     488      uint32_t     m_cpt_xram_rsp_fsm_trt_used;  // NB cycles TRT LOCK used
     489      uint32_t     m_cpt_ixr_fsm_trt_used;       // NB cycles TRT LOCK used
     490     
     491      uint32_t     m_cpt_trt_unused;            // NB cycles TRT LOCK unused
     492
     493      uint32_t     m_cpt_write_fsm_upt_lock;     // wait UPT LOCK
     494      uint32_t     m_cpt_xram_rsp_fsm_upt_lock;  // wait UPT LOCK
     495      uint32_t     m_cpt_multi_ack_fsm_upt_lock; // wait UPT LOCK
     496      uint32_t     m_cpt_cleanup_fsm_ivt_lock;   // wait UPT LOCK
     497      uint32_t     m_cpt_cas_fsm_upt_lock;       // wait UPT LOCK
     498     
     499      uint32_t     m_cpt_write_fsm_n_upt_lock;     // NB UPT LOCK
     500      uint32_t     m_cpt_xram_rsp_fsm_n_upt_lock;  // NB UPT LOCK
     501      uint32_t     m_cpt_multi_ack_fsm_n_upt_lock; // NB UPT LOCK
     502      uint32_t     m_cpt_cleanup_fsm_n_upt_lock;   // NB UPT LOCK
     503      uint32_t     m_cpt_cas_fsm_n_upt_lock;       // NB UPT LOCK
     504     
     505      uint32_t     m_cpt_write_fsm_upt_used;     // NB cycles UPT LOCK used
     506      uint32_t     m_cpt_xram_rsp_fsm_upt_used;  // NB cycles UPT LOCK used
     507      uint32_t     m_cpt_multi_ack_fsm_upt_used; // NB cycles UPT LOCK used
     508      uint32_t     m_cpt_cleanup_fsm_ivt_used;   // NB cycles UPT LOCK used
     509      uint32_t     m_cpt_cas_fsm_upt_used;       // NB cycles UPT LOCK used
     510     
     511      uint32_t     m_cpt_ivt_unused;            // NB cycles UPT LOCK unused
     512      uint32_t     m_cpt_upt_unused;            // NB cycles UPT LOCK unused
     513
     514      uint32_t     m_cpt_read_fsm_heap_lock;     // wait HEAP LOCK
     515      uint32_t     m_cpt_write_fsm_heap_lock;    // wait HEAP LOCK
     516      uint32_t     m_cpt_cas_fsm_heap_lock;      // wait HEAP LOCK
     517      uint32_t     m_cpt_cleanup_fsm_heap_lock;  // wait HEAP LOCK
     518      uint32_t     m_cpt_xram_rsp_fsm_heap_lock; // wait HEAP LOCK
     519     
     520      uint32_t     m_cpt_read_fsm_n_heap_lock;     // NB HEAP LOCK
     521      uint32_t     m_cpt_write_fsm_n_heap_lock;    // NB HEAP LOCK
     522      uint32_t     m_cpt_cas_fsm_n_heap_lock;      // NB HEAP LOCK
     523      uint32_t     m_cpt_cleanup_fsm_n_heap_lock;  // NB HEAP LOCK
     524      uint32_t     m_cpt_xram_rsp_fsm_n_heap_lock; // NB HEAP LOCK
     525     
     526      uint32_t     m_cpt_read_fsm_heap_used;     // NB cycles HEAP LOCK used
     527      uint32_t     m_cpt_write_fsm_heap_used;    // NB cycles HEAP LOCK used
     528      uint32_t     m_cpt_cas_fsm_heap_used;      // NB cycles HEAP LOCK used
     529      uint32_t     m_cpt_cleanup_fsm_heap_used;  // NB cycles HEAP LOCK used
     530      uint32_t     m_cpt_xram_rsp_fsm_heap_used; // NB cycles HEAP LOCK used
     531     
     532      uint32_t     m_cpt_heap_unused;            // NB cycles HEAP LOCK unused
     533
     534      //RWT
     535      uint32_t     m_cpt_cleanup_data;   
     536      uint32_t     m_cpt_ncc_to_cc_read;         // NB change from NCC to CC caused by a READ
     537      uint32_t     m_cpt_ncc_to_cc_write;        // NB change from NCC to CC caused by a WRITE
     538      uint32_t     m_cpt_ncc_to_cc;              // NB change from NCC to CC
     539
     540      uint32_t     m_cpt_read_data_unc;
     541      uint32_t     m_cpt_read_data_miss_CC;
     542      uint32_t     m_cpt_read_ins_unc;
     543      uint32_t     m_cpt_read_ins_miss;
     544      uint32_t     m_cpt_read_ll_CC;
     545      uint32_t     m_cpt_read_data_miss_NCC;
     546      uint32_t     m_cpt_read_ll_NCC;
     547      uint32_t     m_cpt_read_WTF;
    436548
    437549      uint32_t     m_cpt_cleanup_cost;  // Number of (flits * distance) for CLEANUPs
     
    481593      ~VciMemCache();
    482594
     595      void clear_stats();
    483596      void print_stats();
    484597      void print_trace();
     
    657770      sc_signal<addr_t>   r_read_to_tgt_rsp_ll_key; // LL key from the llsc_global_table
    658771
     772      //RWT: Buffer between READ fsm and CC_SEND fsm (send inval)
     773      sc_signal<bool>     r_read_to_cc_send_req;
     774      sc_signal<size_t>   r_read_to_cc_send_dest;
     775      sc_signal<addr_t>   r_read_to_cc_send_nline;
     776      sc_signal<bool>     r_read_to_cc_send_inst;
     777
     778      //RWT: Buffer between READ fsm and CLEANUP fsm (wait for the data coming from L1 cache)
     779      sc_signal<bool>     r_read_to_cleanup_req;    // valid request
     780      sc_signal<addr_t>   r_read_to_cleanup_nline;  // cache line index
     781      sc_signal<size_t>   r_read_to_cleanup_srcid;
     782      sc_signal<size_t>   r_read_to_cleanup_length;
     783      sc_signal<size_t>   r_read_to_cleanup_first_word;
     784      sc_signal<bool>     r_read_to_cleanup_cached_read;   
     785      sc_signal<bool>     r_read_to_cleanup_is_ll;
     786      sc_signal<addr_t>   r_read_to_cleanup_addr;
     787      sc_signal<addr_t>   r_read_to_cleanup_ll_key;
     788
     789      //RWT:
     790      sc_signal<bool>     r_read_coherent;          // State of the cache slot after transaction
     791      sc_signal<bool>     r_read_ll_done;
     792
    659793      ///////////////////////////////////////////////////////////////
    660794      // Registers controlled by the WRITE fsm
     
    721855      sc_signal<size_t>   r_write_to_multi_ack_upt_index; // index in update table
    722856
     857      // RWT: Buffer between WRITE fsm and CLEANUP fsm (change slot state)
     858      sc_signal<bool>     r_write_to_cleanup_req;         // valid request
     859      sc_signal<addr_t>   r_write_to_cleanup_nline;       // cache line index
     860
     861      // RWT
     862      sc_signal<bool>     r_write_coherent;               // cache slot state after transaction
     863
     864      //Buffer between WRITE fsm and CC_SEND fsm (INVAL for RWT)
     865      sc_signal<bool>     r_write_to_cc_send_req;
     866      sc_signal<size_t>   r_write_to_cc_send_dest;
     867
     868
    723869      /////////////////////////////////////////////////////////
    724870      // Registers controlled by MULTI_ACK fsm
     
    788934      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
    789935      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
     936      sc_signal<addr_t>     r_cleanup_to_tgt_rsp_ll_key;
     937
     938      //RWT
     939      sc_signal<size_t>   r_cleanup_read_srcid;
     940      sc_signal<size_t>   r_cleanup_read_trdid;
     941      sc_signal<size_t>   r_cleanup_read_pktid;
     942      sc_signal<bool>     r_cleanup_read_need_rsp;
     943      sc_signal<bool>     r_cleanup_to_tgt_rsp_type;
     944      sc_signal<data_t> * r_cleanup_to_tgt_rsp_data;
     945      sc_signal<size_t>   r_cleanup_to_tgt_rsp_length;
     946      sc_signal<size_t>   r_cleanup_to_tgt_rsp_first_word;
    790947
    791948      ///////////////////////////////////////////////////////
     
    813970      sc_signal<data_t> * r_cas_data;       // cache line data
    814971
     972      sc_signal<bool>     r_cas_coherent;
     973
    815974      // Buffer between CAS fsm and IXR_CMD fsm (XRAM write)
    816975      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
     
    9061065      sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_trdid; // index in transaction table
    9071066
     1067      //RWT
     1068      sc_signal<bool>     r_xram_rsp_victim_coherent;      // victim's cache slot state
     1069      sc_signal<bool>     r_xram_rsp_coherent;             // coherence of the read
    9081070      ////////////////////////////////////////////////////
    9091071      // Registers controlled by the IXR_CMD fsm
     
    9661128      sc_signal<int>      r_alloc_heap_fsm;
    9671129      sc_signal<unsigned> r_alloc_heap_reset_cpt;
     1130
     1131
     1132      ////////////////////////////////////////////////////
     1133      // REGISTERS FOR ODCCP
     1134      ////////////////////////////////////////////////////
     1135
     1136      sc_signal<uint32_t>  r_cleanup_data_index;
     1137      sc_signal<uint32_t>  r_cleanup_trdid;
     1138      sc_signal<uint32_t>  r_cleanup_pktid;
     1139      sc_signal<bool>      r_cleanup_coherent;
     1140      sc_signal<data_t>    *r_cleanup_data;
     1141      sc_signal<data_t>    *r_cleanup_old_data;
     1142      sc_signal<bool>      r_cleanup_contains_data;
     1143     
     1144      sc_signal<bool>      r_cleanup_ncc;
     1145      sc_signal<bool>      r_cleanup_to_ixr_cmd_ncc_l1_dirty;
     1146      sc_signal<bool>      r_xram_rsp_to_ixr_cmd_inval_ncc_pending;
     1147     
     1148      sc_signal<bool>      r_cleanup_to_ixr_cmd_req;
     1149      sc_signal<data_t>    *r_cleanup_to_ixr_cmd_data;
     1150      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_srcid;
     1151      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_trdid;
     1152      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_pktid;
     1153      sc_signal<addr_t>    r_cleanup_to_ixr_cmd_nline;
    9681154    }; // end class VciMemCache
    9691155
  • branches/RWT/modules/vci_mem_cache/caba/source/include/xram_transaction.h

    r422 r477  
    294294    }
    295295
     296    ///////////////////////////////////////////////////////////////////////
     297    // The hit_write() function looks if an XRAM write transaction exists
     298    // for a given line.
     299    // Arguments :
     300    // - index : (return argument) the index of the hit entry, if there is
     301    // - nline : the index (zy) of the requested line
     302    // The function returns true if a write request has already been sent
     303    ///////////////////////////////////////////////////////////////////////
     304    bool hit_write(const addr_t nline, size_t* index)
     305    {
     306        for(size_t i=0; i<size_tab; i++){
     307            if(tab[i].valid && (nline==tab[i].nline) && !(tab[i].xram_read)) {
     308                *index = i;
     309                return true;   
     310            }
     311        }
     312        return false;
     313    }
    296314    /////////////////////////////////////////////////////////////////////
    297315    // The write_data_mask() function writes a vector of data (a line).
  • branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r468 r477  
    107107  "CC_SEND_XRAM_RSP_INVAL_HEADER",
    108108  "CC_SEND_XRAM_RSP_INVAL_NLINE",
     109  "CC_SEND_READ_NCC_INVAL_HEADER",
     110  "CC_SEND_READ_NCC_INVAL_NLINE",
     111  "CC_SEND_WRITE_NCC_INVAL_HEADER",
     112  "CC_SEND_WRITE_NCC_INVAL_NLINE",
    109113  "CC_SEND_WRITE_BRDCAST_HEADER",
    110114  "CC_SEND_WRITE_BRDCAST_NLINE",
     
    148152  "READ_DIR_REQ",
    149153  "READ_DIR_LOCK",
     154  "READ_IVT_LOCK",
     155  "READ_WAIT",
    150156  "READ_DIR_HIT",
    151157  "READ_HEAP_REQ",
     
    165171  "WRITE_DIR_REQ",
    166172  "WRITE_DIR_LOCK",
     173  "WRITE_IVT_LOCK_HIT_WB",
    167174  "WRITE_DIR_READ",
    168175  "WRITE_DIR_HIT",
     
    173180  "WRITE_UPT_DEC",
    174181  "WRITE_RSP",
     182  "WRITE_MISS_IVT_LOCK",
    175183  "WRITE_MISS_TRT_LOCK",
    176184  "WRITE_MISS_TRT_DATA",
     
    215223  "IXR_CMD_CAS_IDLE",
    216224  "IXR_CMD_XRAM_IDLE",
     225  "IXR_CMD_CLEANUP_IDLE",
    217226  "IXR_CMD_READ",
    218227  "IXR_CMD_WRITE",
    219228  "IXR_CMD_CAS",
    220   "IXR_CMD_XRAM"
     229  "IXR_CMD_XRAM",
     230  "IXR_CMD_CLEANUP_DATA"
    221231};
    222232const char *cas_fsm_str[] =
     
    248258  "CLEANUP_IDLE",
    249259  "CLEANUP_GET_NLINE",
     260  "CLEANUP_GET_DATA",
    250261  "CLEANUP_DIR_REQ",
    251262  "CLEANUP_DIR_LOCK",
    252263  "CLEANUP_DIR_WRITE",
     264  "CLEANUP_IVT_LOCK_DATA",
     265  "CLEANUP_IVT_CLEAR_DATA",
     266  "CLEANUP_READ_RSP",
    253267  "CLEANUP_HEAP_REQ",
    254268  "CLEANUP_HEAP_LOCK",
     
    260274  "CLEANUP_IVT_CLEAR",
    261275  "CLEANUP_WRITE_RSP",
     276  "CLEANUP_IXR_REQ",
     277  "CLEANUP_WAIT",
    262278  "CLEANUP_CONFIG_ACK",
    263279  "CLEANUP_SEND_CLACK"
     
    279295  "ALLOC_TRT_CAS",
    280296  "ALLOC_TRT_XRAM_RSP",
    281   "ALLOC_TRT_IXR_RSP"
     297  "ALLOC_TRT_IXR_RSP",
     298  "ALLOC_TRT_CLEANUP"
    282299};
    283300const char *alloc_upt_fsm_str[] =
     
    290307{
    291308  "ALLOC_IVT_WRITE",
     309  "ALLOC_IVT_READ",
    292310  "ALLOC_IVT_XRAM_RSP",
    293311  "ALLOC_IVT_CLEANUP",
     
    339357  : soclib::caba::BaseModule(name),
    340358
     359    m_monitor_ok(false),
    341360    p_clk( "p_clk" ),
    342361    p_resetn( "p_resetn" ),
     
    526545    r_cas_data                 = new sc_signal<data_t>[nwords];
    527546    r_cas_rdata                = new sc_signal<data_t>[2];
     547
     548    // Allocation for ODCCP
     549    r_cleanup_data             = new sc_signal<data_t>[nwords];
     550    r_cleanup_to_ixr_cmd_data  = new sc_signal<data_t>[nwords];
     551    r_cleanup_to_tgt_rsp_data  = new sc_signal<data_t>[nwords];
     552    r_cleanup_old_data         = new sc_signal<data_t>[nwords];
    528553
    529554    // Allocation for debug
     
    641666
    642667/////////////////////////////////////////
     668tmpl(void) ::clear_stats()
     669/////////////////////////////////////////
     670{
     671
     672    m_cpt_cycles                  = 0;
     673    m_cpt_read                    = 0;
     674    m_cpt_read_miss               = 0;
     675    m_cpt_write                   = 0;
     676    m_cpt_write_miss              = 0;
     677    m_cpt_write_cells             = 0;
     678    m_cpt_write_dirty             = 0;
     679    m_cpt_update                  = 0;
     680    m_cpt_update_mult             = 0;
     681    m_cpt_inval_brdcast           = 0;
     682    m_cpt_inval                   = 0;
     683    m_cpt_inval_mult              = 0;
     684    m_cpt_cleanup                 = 0;
     685    m_cpt_ll                      = 0;
     686    m_cpt_sc                      = 0;
     687    m_cpt_cas                     = 0;
     688    m_cpt_trt_full                = 0;
     689    m_cpt_trt_rb                  = 0;
     690    m_cpt_dir_unused              = 0;
     691    m_cpt_ivt_unused              = 0;
     692    m_cpt_upt_unused              = 0;
     693    m_cpt_heap_unused             = 0;
     694    m_cpt_trt_unused              = 0;
     695    m_cpt_read_fsm_n_dir_lock     = 0;
     696    m_cpt_read_fsm_dir_lock       = 0;
     697    m_cpt_read_fsm_dir_used       = 0;
     698    m_cpt_read_fsm_trt_lock       = 0;
     699    m_cpt_read_fsm_heap_lock      = 0;
     700    m_cpt_write_fsm_dir_lock      = 0;
     701    m_cpt_write_fsm_n_dir_lock    = 0;
     702    m_cpt_write_fsm_upt_lock      = 0;
     703    m_cpt_write_fsm_heap_lock     = 0;
     704    m_cpt_write_fsm_dir_used      = 0;
     705    m_cpt_write_fsm_trt_lock      = 0;
     706    m_cpt_cas_fsm_n_dir_lock      = 0;
     707    m_cpt_cas_fsm_dir_lock        = 0;
     708    m_cpt_cas_fsm_upt_lock        = 0;
     709    m_cpt_cas_fsm_heap_lock       = 0;
     710    m_cpt_cas_fsm_trt_lock        = 0;
     711    m_cpt_cas_fsm_dir_used        = 0;
     712    m_cpt_xram_rsp_fsm_n_dir_lock = 0;
     713    m_cpt_xram_rsp_fsm_dir_lock   = 0;
     714    m_cpt_xram_rsp_fsm_trt_lock   = 0;
     715    m_cpt_xram_rsp_fsm_upt_lock   = 0;
     716    m_cpt_xram_rsp_fsm_heap_lock  = 0;
     717    m_cpt_xram_rsp_fsm_dir_used   = 0;
     718    m_cpt_cleanup_fsm_dir_lock    = 0;
     719    m_cpt_cleanup_fsm_n_dir_lock  = 0;
     720    m_cpt_cleanup_fsm_heap_lock   = 0;
     721    m_cpt_cleanup_fsm_ivt_lock    = 0;
     722    m_cpt_cleanup_fsm_dir_used    = 0;
     723    m_cpt_ixr_fsm_trt_lock        = 0;
     724    m_cpt_multi_ack_fsm_upt_lock  = 0;
     725    m_cpt_read_data_unc           = 0;   
     726    m_cpt_read_data_miss_CC       = 0;   
     727    m_cpt_read_ins_unc            = 0;       
     728    m_cpt_read_ins_miss           = 0;     
     729    m_cpt_read_ll_CC              = 0;       
     730    m_cpt_read_data_miss_NCC      = 0;       
     731    m_cpt_read_ll_NCC             = 0;   
     732    m_cpt_read_WTF                = 0;   
     733    m_cpt_cleanup_data            = 0;     
     734    m_cpt_ncc_to_cc_read          = 0;     
     735    m_cpt_ncc_to_cc_write         = 0;       
     736    m_cpt_ncc_to_cc               = 0;       
     737}
     738
     739/////////////////////////////////////////
    643740tmpl(void) ::print_stats()
    644741/////////////////////////////////////////
     
    647744  std::cout
    648745      << "MEM_CACHE " << name() << " / Time = " << m_cpt_cycles << std::endl
    649       << "- READ RATE            = " << (double) m_cpt_read/m_cpt_cycles << std::endl
    650       << "- READ TOTAL           = " << m_cpt_read << std::endl
    651       << "- READ MISS RATE       = " << (double) m_cpt_read_miss/m_cpt_read << std::endl
    652       << "- WRITE RATE           = " << (double) m_cpt_write/m_cpt_cycles << std::endl
    653       << "- WRITE TOTAL          = " << m_cpt_write << std::endl
    654       << "- WRITE MISS RATE      = " << (double) m_cpt_write_miss/m_cpt_write << std::endl
    655       << "- WRITE BURST LENGTH   = " << (double) m_cpt_write_cells/m_cpt_write << std::endl
    656       << "- WRITE BURST TOTAL    = " << m_cpt_write_cells << std::endl
    657       << "- REQUESTS TRT FULL    = " << m_cpt_trt_full << std::endl
    658       << "- READ TRT BLOKED HIT  = " << m_cpt_trt_rb << std::endl
    659       << "- UPDATE RATE          = " << (double) m_cpt_update/m_cpt_cycles << std::endl
    660       << "- UPDATE ARITY         = " << (double) m_cpt_update_mult/m_cpt_update << std::endl
    661       << "- INVAL MULTICAST RATE = " << (double)(m_cpt_inval-m_cpt_inval_brdcast) /m_cpt_cycles << std::endl
    662       << "- INVAL MULTICAST ARITY= " << (double) m_cpt_inval_mult/ (m_cpt_inval-m_cpt_inval_brdcast) << std::endl
    663       << "- INVAL BROADCAST RATE = " << (double) m_cpt_inval_brdcast/m_cpt_cycles << std::endl
    664       << "- SAVE DIRTY RATE      = " << (double) m_cpt_write_dirty/m_cpt_cycles << std::endl
    665       << "- CLEANUP RATE         = " << (double) m_cpt_cleanup/m_cpt_cycles << std::endl
    666       << "- LL RATE              = " << (double) m_cpt_ll/m_cpt_cycles << std::endl
    667       << "- SC RATE              = " << (double) m_cpt_sc/m_cpt_cycles << std::endl
    668       << "- CAS RATE             = " << (double) m_cpt_cas/m_cpt_cycles << std::endl;
     746      << "- READ RATE                              = " << (double) m_cpt_read/m_cpt_cycles << std::endl
     747      << "- READ TOTAL                             = " << m_cpt_read << std::endl
     748      << "- READ MISS RATE                         = " << (double) m_cpt_read_miss/m_cpt_read << std::endl
     749      << "- WRITE RATE                             = " << (double) m_cpt_write/m_cpt_cycles << std::endl
     750      << "- WRITE TOTAL                            = " << m_cpt_write << std::endl
     751      << "- WRITE MISS RATE                        = " << (double) m_cpt_write_miss/m_cpt_write << std::endl
     752      << "- WRITE BURST LENGTH                     = " << (double) m_cpt_write_cells/m_cpt_write << std::endl
     753      << "- WRITE BURST TOTAL                      = " << m_cpt_write_cells << std::endl
     754      << "- REQUESTS TRT FULL                      = " << m_cpt_trt_full << std::endl
     755      << "- READ TRT BLOKED HIT                    = " << m_cpt_trt_rb << std::endl
     756      << "- UPDATE RATE                            = " << (double) m_cpt_update/m_cpt_cycles << std::endl
     757      << "- UPDATE ARITY                           = " << (double) m_cpt_update_mult/m_cpt_update << std::endl
     758      << "- INVAL MULTICAST RATE                   = " << (double)(m_cpt_inval-m_cpt_inval_brdcast) /m_cpt_cycles << std::endl
     759      << "- INVAL MULTICAST ARITY                  = " << (double) m_cpt_inval_mult/ (m_cpt_inval-m_cpt_inval_brdcast) << std::endl
     760      << "- INVAL BROADCAST RATE                   = " << (double) m_cpt_inval_brdcast/m_cpt_cycles << std::endl
     761      << "- SAVE DIRTY RATE                        = " << (double) m_cpt_write_dirty/m_cpt_cycles << std::endl
     762      << "- CLEANUP RATE                           = " << (double) m_cpt_cleanup/m_cpt_cycles << std::endl
     763      << "- LL RATE                                = " << (double) m_cpt_ll/m_cpt_cycles << std::endl
     764      << "- SC RATE                                = " << (double) m_cpt_sc/m_cpt_cycles << std::endl
     765      << "- CAS RATE                               = " << (double) m_cpt_cas/m_cpt_cycles << std::endl << std::endl
     766
     767      << "- WAIT DIR LOCK in READ_FSM              = " << (double) m_cpt_read_fsm_dir_lock/m_cpt_read_fsm_n_dir_lock << std::endl
     768      << "- NB CYCLES IN DIR LOCK in READ_FSM      = " << (double) m_cpt_read_fsm_dir_used/m_cpt_read_fsm_n_dir_lock << std::endl
     769      << "- WAIT DIR LOCK in WRITE_FSM             = " << (double) m_cpt_write_fsm_dir_lock/m_cpt_write_fsm_n_dir_lock << std::endl
     770      << "- NB CYCLES IN DIR LOCK in WRITE_FSM     = " << (double) m_cpt_write_fsm_dir_used/m_cpt_write_fsm_n_dir_lock << std::endl
     771      << "- WAIT DIR LOCK in XRAM_FSM              = " << (double) m_cpt_xram_rsp_fsm_dir_lock/m_cpt_xram_rsp_fsm_n_dir_lock << std::endl
     772      << "- NB CYCLES IN DIR LOCK in XRAM_FSM      = " << (double) m_cpt_xram_rsp_fsm_dir_used/m_cpt_xram_rsp_fsm_n_dir_lock << std::endl
     773      << "- WAIT DIR LOCK in CLEANUP_FSM           = " << (double) m_cpt_cleanup_fsm_dir_lock/m_cpt_cleanup_fsm_n_dir_lock << std::endl
     774      << "- NB CYCLES IN DIR LOCK in CLEANUP_FSM   = " << (double) m_cpt_cleanup_fsm_dir_used/m_cpt_cleanup_fsm_n_dir_lock << std::endl
     775      << "- WAIT DIR LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_dir_lock/m_cpt_cas_fsm_n_dir_lock << std::endl
     776      << "- NB CYCLES IN LOCK in CAS_FSM           = " << (double) m_cpt_cas_fsm_dir_used/m_cpt_cas_fsm_n_dir_lock << std::endl
     777      << "- DIR UNUSED RATE                        = " << (double) m_cpt_dir_unused/m_cpt_cycles << std::endl << std::endl
     778     
     779      << "- WAIT TRT LOCK in READ_FSM              = " << (double) m_cpt_read_fsm_trt_lock/m_cpt_read_fsm_n_trt_lock << std::endl
     780      << "- NB CYCLES IN TRT LOCK in READ_FSM      = " << (double) m_cpt_read_fsm_trt_used/m_cpt_read_fsm_n_trt_lock << std::endl
     781      << "- WAIT TRT LOCK in WRITE_FSM             = " << (double) m_cpt_write_fsm_trt_lock/m_cpt_write_fsm_n_trt_lock << std::endl
     782      << "- NB CYCLES IN TRT LOCK in WRITE_FSM     = " << (double) m_cpt_write_fsm_trt_used/m_cpt_write_fsm_n_trt_lock << std::endl
     783      << "- WAIT TRT LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_trt_lock/m_cpt_cas_fsm_n_trt_lock << std::endl
     784      << "- NB CYCLES IN TRT LOCK in CAS_FSM       = " << (double) m_cpt_cas_fsm_trt_used/m_cpt_cas_fsm_n_trt_lock << std::endl
     785      << "- WAIT TRT LOCK in XRAM_FSM              = " << (double) m_cpt_xram_rsp_fsm_trt_lock/m_cpt_xram_rsp_fsm_n_trt_lock << std::endl
     786      << "- NB CYCLES IN TRT LOCK in XRAM_FSM      = " << (double) m_cpt_xram_rsp_fsm_trt_used/m_cpt_xram_rsp_fsm_n_trt_lock << std::endl
     787      << "- WAIT TRT LOCK in IXR_FSM               = " << (double) m_cpt_ixr_fsm_trt_lock/m_cpt_ixr_fsm_n_trt_lock << std::endl
     788      << "- NB CYCLES IN TRT LOCK in IXR_FSM       = " << (double) m_cpt_ixr_fsm_trt_used/m_cpt_ixr_fsm_n_trt_lock << std::endl
     789      << "- TRT UNUSED RATE                        = " << (double) m_cpt_trt_unused/m_cpt_cycles << std::endl << std::endl
     790     
     791      << "- WAIT UPT LOCK in WRITE_FSM             = " << (double) m_cpt_write_fsm_upt_lock/m_cpt_write_fsm_n_upt_lock << std::endl
     792      << "- NB CYCLES IN UPT LOCK in WRITE_FSM     = " << (double) m_cpt_write_fsm_upt_used/m_cpt_write_fsm_n_upt_lock << std::endl
     793      << "- WAIT UPT LOCK in XRAM_FSM              = " << (double) m_cpt_xram_rsp_fsm_upt_lock/m_cpt_xram_rsp_fsm_n_upt_lock << std::endl
     794      << "- NB CYCLES IN UPT LOCK in XRAM_FSM      = " << (double) m_cpt_xram_rsp_fsm_upt_used/m_cpt_xram_rsp_fsm_n_upt_lock << std::endl
     795      << "- WAIT UPT LOCK in MULTIACK_FSM          = " << (double) m_cpt_multi_ack_fsm_upt_lock/m_cpt_multi_ack_fsm_n_upt_lock << std::endl
     796      << "- NB CYCLES IN UPT LOCK in MULTIACK_FSM  = " << (double) m_cpt_multi_ack_fsm_upt_used/m_cpt_multi_ack_fsm_n_upt_lock << std::endl
     797      << "- WAIT UPT LOCK in CLEANUP_FSM           = " << (double) m_cpt_cleanup_fsm_ivt_lock/m_cpt_cleanup_fsm_n_upt_lock << std::endl
     798      << "- NB CYCLES IN UPT LOCK in CLEANUP_FSM   = " << (double) m_cpt_cleanup_fsm_ivt_used/m_cpt_cleanup_fsm_n_upt_lock << std::endl
     799      << "- WAIT UPT LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_upt_lock/m_cpt_cas_fsm_n_upt_lock << std::endl
     800      << "- NB CYCLES IN UPT LOCK in CAS_FSM       = " << (double) m_cpt_cas_fsm_upt_used/m_cpt_cas_fsm_n_upt_lock << std::endl
     801      << "- UPT UNUSED RATE                        = " << (double) m_cpt_upt_unused/m_cpt_cycles << std::endl << std::endl
     802      << "- IVT UNUSED RATE                        = " << (double) m_cpt_ivt_unused/m_cpt_cycles << std::endl << std::endl
     803     
     804      << "- WAIT HEAP LOCK in READ_FSM             = " << (double) m_cpt_read_fsm_heap_lock/m_cpt_read_fsm_n_heap_lock << std::endl
     805      << "- NB CYCLES IN HEAP LOCK in READ_FSM     = " << (double) m_cpt_read_fsm_heap_used/m_cpt_read_fsm_n_heap_lock << std::endl
     806      << "- WAIT HEAP LOCK in WRITE_FSM            = " << (double) m_cpt_write_fsm_heap_lock/m_cpt_write_fsm_n_heap_lock << std::endl
     807      << "- NB CYCLES IN HEAP LOCK in WRITE_FSM    = " << (double) m_cpt_write_fsm_heap_used/m_cpt_write_fsm_n_heap_lock << std::endl
     808      << "- WAIT HEAP LOCK in XRAM_FSM             = " << (double) m_cpt_xram_rsp_fsm_heap_lock/m_cpt_xram_rsp_fsm_n_heap_lock << std::endl
     809      << "- NB CYCLES IN HEAP LOCK in XRAM_FSM     = " << (double) m_cpt_xram_rsp_fsm_heap_used/m_cpt_xram_rsp_fsm_n_heap_lock << std::endl
     810      << "- WAIT HEAP LOCK in CLEANUP_FSM          = " << (double) m_cpt_cleanup_fsm_heap_lock/m_cpt_cleanup_fsm_n_heap_lock << std::endl
     811      << "- NB CYCLES IN HEAP LOCK in CLEANUP_FSM  = " << (double) m_cpt_cleanup_fsm_heap_used/m_cpt_cleanup_fsm_n_heap_lock << std::endl
     812      << "- WAIT HEAP LOCK in CAS_FSM              = " << (double) m_cpt_cas_fsm_heap_lock/m_cpt_cas_fsm_n_heap_lock << std::endl
     813      << "- NB CYCLES IN HEAP LOCK in CAS_FSM      = " << (double) m_cpt_cas_fsm_heap_used/m_cpt_cas_fsm_n_heap_lock << std::endl
     814      << "- HEAP UNUSED RATE                       = " << (double) m_cpt_heap_unused/m_cpt_cycles << std::endl
     815
     816      << "- READ DATA UNC                          = " << (double) m_cpt_read_data_unc << std::endl
     817      << "- READ DATA MISS CC                      = " << (double) m_cpt_read_data_miss_CC << std::endl
     818      << "- READ INS UNC                           = " << (double) m_cpt_read_ins_unc << std::endl
     819      << "- READ INS MISS                          = " << (double) m_cpt_read_ins_miss << std::endl
     820      << "- READ LL CC                             = " << (double) m_cpt_read_ll_CC << std::endl
     821      << "- READ DATA MISS NCC                     = " << (double) m_cpt_read_data_miss_NCC << std::endl
     822      << "- READ LL NCC                            = " << (double) m_cpt_read_ll_NCC << std::endl
     823      << "- READ OTHER                             = " << (double) m_cpt_read_WTF << std::endl
     824      << "- CLEANUP + DATA                         = " << (double) m_cpt_cleanup_data << std::endl
     825      << "- NCC TO CC READ                         = " << (double) m_cpt_ncc_to_cc_read << std::endl
     826      << "- NCC TO CC WRITE                        = " << (double) m_cpt_ncc_to_cc_write << std::endl
     827      << "- NCC TO CC                              = " << (double) m_cpt_ncc_to_cc << std::endl;
    669828}
    670829
     
    685844  delete [] r_write_be;
    686845  delete [] r_write_to_cc_send_data;
     846
     847  delete [] r_cleanup_data;
     848  delete [] r_cleanup_to_ixr_cmd_data;
     849  delete [] r_cleanup_to_tgt_rsp_data;
     850  delete [] r_cleanup_old_data;
    687851}
    688852
     
    763927    r_read_to_tgt_rsp_req = false;
    764928    r_read_to_ixr_cmd_req = false;
     929    r_read_to_cc_send_req = false;
     930    r_read_to_cleanup_req = false;
    765931
    766932    r_write_to_tgt_rsp_req          = false;
     
    820986    r_tgt_rsp_key_sent  = false;
    821987
     988    // ODCCP
     989    r_cleanup_data_index       = 0;
     990    r_cleanup_trdid            = 0;
     991    r_cleanup_pktid            = 0;
     992    r_cleanup_contains_data    = false;
     993    r_cleanup_ncc              = false;
     994    r_cleanup_to_ixr_cmd_ncc_l1_dirty    = false;
     995    r_xram_rsp_to_ixr_cmd_inval_ncc_pending    = false;
     996    r_cleanup_to_ixr_cmd_req   = false;
     997    r_cleanup_to_ixr_cmd_srcid = 0;
     998    r_cleanup_to_ixr_cmd_trdid = 0;
     999    r_cleanup_to_ixr_cmd_pktid = 0;
     1000    r_cleanup_to_ixr_cmd_nline = 0;
     1001    for (size_t word = 0; word < m_words; word ++)
     1002    {
     1003      r_cleanup_to_ixr_cmd_data[word] = 0;
     1004      r_cleanup_data[word] = 0;
     1005    }
     1006
     1007
    8221008    // Activity counters
    823     m_cpt_cycles        = 0;
    824     m_cpt_read          = 0;
    825     m_cpt_read_miss     = 0;
    826     m_cpt_write         = 0;
    827     m_cpt_write_miss    = 0;
    828     m_cpt_write_cells   = 0;
    829     m_cpt_write_dirty   = 0;
    830     m_cpt_update        = 0;
    831     m_cpt_update_mult   = 0;
    832     m_cpt_inval_brdcast = 0;
    833     m_cpt_inval         = 0;
    834     m_cpt_inval_mult    = 0;
    835     m_cpt_cleanup       = 0;
    836     m_cpt_ll            = 0;
    837     m_cpt_sc            = 0;
    838     m_cpt_cas           = 0;
    839     m_cpt_trt_full      = 0;
    840     m_cpt_trt_rb        = 0;
    841 
     1009    m_cpt_cycles                  = 0;
     1010    m_cpt_read                    = 0;
     1011    m_cpt_read_miss               = 0;
     1012    m_cpt_write                   = 0;
     1013    m_cpt_write_miss              = 0;
     1014    m_cpt_write_cells             = 0;
     1015    m_cpt_write_dirty             = 0;
     1016    m_cpt_update                  = 0;
     1017    m_cpt_update_mult             = 0;
     1018    m_cpt_inval_brdcast           = 0;
     1019    m_cpt_inval                   = 0;
     1020    m_cpt_inval_mult              = 0;
     1021    m_cpt_cleanup                 = 0;
     1022    m_cpt_ll                      = 0;
     1023    m_cpt_sc                      = 0;
     1024    m_cpt_cas                     = 0;
     1025    m_cpt_trt_full                = 0;
     1026    m_cpt_trt_rb                  = 0;
     1027    m_cpt_dir_unused              = 0;
     1028    m_cpt_upt_unused              = 0;
     1029    m_cpt_ivt_unused              = 0;
     1030    m_cpt_heap_unused             = 0;
     1031    m_cpt_trt_unused              = 0;
     1032    m_cpt_read_fsm_n_dir_lock     = 0;
     1033    m_cpt_read_fsm_dir_lock       = 0;
     1034    m_cpt_read_fsm_dir_used       = 0;
     1035    m_cpt_read_fsm_trt_lock       = 0;
     1036    m_cpt_read_fsm_heap_lock      = 0;
     1037    m_cpt_write_fsm_dir_lock      = 0;
     1038    m_cpt_write_fsm_n_dir_lock    = 0;
     1039    m_cpt_write_fsm_upt_lock      = 0;
     1040    m_cpt_write_fsm_heap_lock     = 0;
     1041    m_cpt_write_fsm_dir_used      = 0;
     1042    m_cpt_write_fsm_trt_lock      = 0;
     1043    m_cpt_cas_fsm_n_dir_lock      = 0;
     1044    m_cpt_cas_fsm_dir_lock        = 0;
     1045    m_cpt_cas_fsm_upt_lock        = 0;
     1046    m_cpt_cas_fsm_heap_lock       = 0;
     1047    m_cpt_cas_fsm_trt_lock        = 0;
     1048    m_cpt_cas_fsm_dir_used        = 0;
     1049    m_cpt_xram_rsp_fsm_n_dir_lock = 0;
     1050    m_cpt_xram_rsp_fsm_dir_lock   = 0;
     1051    m_cpt_xram_rsp_fsm_trt_lock   = 0;
     1052    m_cpt_xram_rsp_fsm_upt_lock   = 0;
     1053    m_cpt_xram_rsp_fsm_heap_lock  = 0;
     1054    m_cpt_xram_rsp_fsm_dir_used   = 0;
     1055    m_cpt_cleanup_fsm_dir_lock    = 0;
     1056    m_cpt_cleanup_fsm_n_dir_lock  = 0;
     1057    m_cpt_cleanup_fsm_heap_lock   = 0;
     1058    m_cpt_cleanup_fsm_ivt_lock    = 0;
     1059    m_cpt_cleanup_fsm_dir_used    = 0;
     1060    m_cpt_ixr_fsm_trt_lock        = 0;
     1061    m_cpt_multi_ack_fsm_upt_lock  = 0;
     1062    m_cpt_read_data_unc           = 0;   
     1063    m_cpt_read_data_miss_CC       = 0;   
     1064    m_cpt_read_ins_unc            = 0;       
     1065    m_cpt_read_ins_miss           = 0;     
     1066    m_cpt_read_ll_CC              = 0;       
     1067    m_cpt_read_data_miss_NCC      = 0;       
     1068    m_cpt_read_ll_NCC             = 0;   
     1069    m_cpt_read_WTF                = 0;   
     1070    m_cpt_cleanup_data            = 0;     
     1071    m_cpt_ncc_to_cc_read          = 0;     
     1072    m_cpt_ncc_to_cc_write         = 0;       
     1073    m_cpt_ncc_to_cc               = 0;       
    8421074    return;
    8431075  }
     
    9461178    if(p_vci_tgt.cmdval)
    9471179    {
     1180
    9481181
    9491182#if DEBUG_MEMC_TGT_CMD
     
    11061339            error            = 0;
    11071340            r_config_address = (r_config_address.read() & 0x00000000FFFFFFFFLL) |
    1108                                ((addr_t)p_vci_tgt.wdata.read())<<32;
     1341                               ((uint64_t)p_vci_tgt.wdata.read())<<32;
    11091342        }
    11101343        else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
     
    13311564    case MULTI_ACK_UPT_LOCK:
    13321565    {
     1566        m_cpt_multi_ack_fsm_upt_lock++;
    13331567        // get lock to the UPDATE table
    1334         if(r_alloc_upt_fsm.read() != ALLOC_UPT_MULTI_ACK) break;
     1568        if(r_alloc_upt_fsm.read() != ALLOC_UPT_MULTI_ACK)  break;
    13351569
    13361570        // decrement the number of expected responses
    13371571        size_t count = 0;
    13381572        bool valid   = m_upt.decrement(r_multi_ack_upt_index.read(), count);
     1573
     1574       /*ODCCP*/ //m_upt.print();
    13391575
    13401576        if(not valid)
     
    13611597          << " entry = "       << r_multi_ack_upt_index.read()
    13621598          << " / rsp_count = " << std::dec << count << std::endl;
     1599        m_cpt_multi_ack_fsm_n_upt_lock++;
    13631600#endif
    13641601        break;
     
    18752112            << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
    18762113#endif
     2114        r_read_coherent = false; //WB by default
     2115        r_read_ll_done  = false;
    18772116        r_read_fsm = READ_DIR_REQ;
    18782117      }
     
    18862125      {
    18872126        r_read_fsm = READ_DIR_LOCK;
     2127        m_cpt_read_fsm_n_dir_lock++;
    18882128      }
    18892129
     
    18922132std::cout << "  <MEMC " << name() << " READ_DIR_REQ> Requesting DIR lock " << std::endl;
    18932133#endif
     2134
     2135      m_cpt_read_fsm_dir_lock++;
     2136
    18942137      break;
    18952138    }
     
    19032146        DirectoryEntry entry =
    19042147          m_cache_directory.read(m_cmd_read_addr_fifo.read(), way);
    1905         // access the global table ONLY when we have an LL cmd
    1906         if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL)   
    1907         {
    1908           r_read_ll_key   = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
     2148        if(((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) and not r_read_ll_done.read())   // access the global table ONLY when we have an LL cmd
     2149        {
     2150          addr_t      nline      = m_nline[(addr_t)(m_cmd_read_addr_fifo.read())];
     2151          r_read_ll_key   = m_llsc_table.ll(nline);
     2152          //r_read_ll_key   = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
     2153          /**//*std::cout << "MEMCACHE : from proc " << m_cmd_read_srcid_fifo.read()
     2154                        << " | @ " << std::hex << m_cmd_read_addr_fifo.read()
     2155                        << " | LL" << std::endl;*/
     2156          r_read_ll_done  = true;
    19092157        }
    19102158        r_read_is_cnt     = entry.is_cnt;
     
    19262174        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    19272175        bool cached_read = (m_cmd_read_pktid_fifo.read() & 0x1);
     2176
     2177
    19282178        if(entry.valid)    // hit
    19292179        {
    1930           // test if we need to register a new copy in the heap
    1931           if(entry.is_cnt or (entry.count == 0) or !cached_read)
     2180          r_read_coherent = entry.cache_coherent;
     2181          if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read())) //hit on a WT line or the owner has no more copy (if LL, the owner must be invalidated even if he made the request)
    19322182          {
    1933             r_read_fsm = READ_DIR_HIT;
     2183            // test if we need to register a new copy in the heap
     2184            if(entry.is_cnt || (entry.count == 0) || !cached_read)
     2185            {
     2186              r_read_fsm = READ_DIR_HIT;
     2187            }
     2188            else
     2189            {
     2190              //std::cout << "is LL = " << ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) << std::endl;
     2191              //std::cout << "coherent = " << entry.cache_coherent << " | count = " << std::dec << entry.count << " | cached = " << cached_read << std::endl;
     2192              r_read_fsm = READ_HEAP_REQ;
     2193            }
    19342194          }
    1935           else
     2195          else //hit on a WB line owned by an other proc
    19362196          {
    1937             r_read_fsm = READ_HEAP_REQ;
     2197            r_read_fsm = READ_IVT_LOCK;
    19382198          }
    19392199        }
     
    19502210          << " / hit = " << std::dec << entry.valid
    19512211          << " / count = " <<std::dec << entry.count
    1952           << " / is_cnt = " << entry.is_cnt;
     2212          << " / is_cnt = " << entry.is_cnt
     2213          << " / is_coherent = " << entry.cache_coherent;
    19532214if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) std::cout << " / LL access" << std::endl;
    19542215else                                                std::cout << std::endl;
     
    19652226    }
    19662227
     2228    ///////////////////
     2229    case READ_IVT_LOCK:
     2230    {
     2231      if (r_alloc_ivt_fsm.read() == ALLOC_IVT_READ)
     2232      {
     2233        size_t index;
     2234        addr_t nline = m_nline[(addr_t)(m_cmd_read_addr_fifo.read())];
     2235        /*std::cout << "nline = " << std::dec <<  nline << std::endl
     2236                  << "inval en cours sur la ligne = " << m_upt.search_inval(nline, index) << std::endl
     2237                  << "UPT full = " << m_upt.is_full() << std::endl
     2238                  << "CC_SEND req = " << r_read_to_cc_send_req.read() << std::endl
     2239                  << "CLENAUP req = " <<r_read_to_cleanup_req.read() << std::endl;*/
     2240        if(m_upt.search_inval(nline, index) or m_upt.is_full() or r_read_to_cc_send_req.read() or r_read_to_cleanup_req.read()) //Check pending inval
     2241        {
     2242          r_read_fsm = READ_WAIT;
     2243#if DEBUG_MEMC_READ
     2244        if(m_debug)
     2245        {
     2246          std::cout
     2247              << "  <MEMC " << name() << " READ_IVT_LOCK>"
     2248              << " Wait cleanup completion"
     2249              << std::endl;
     2250        }
     2251#endif
     2252        }
     2253        else
     2254        {
     2255          r_read_to_cc_send_req = true;
     2256          r_read_to_cc_send_dest = r_read_copy.read();
     2257          r_read_to_cc_send_nline = nline;
     2258          r_read_to_cc_send_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
     2259          r_read_to_cleanup_req = true;
     2260          r_read_to_cleanup_nline = nline;
     2261          r_read_to_cleanup_srcid = m_cmd_read_srcid_fifo.read();
     2262          r_read_to_cleanup_length  = m_cmd_read_length_fifo.read();
     2263          r_read_to_cleanup_first_word = m_x[(addr_t) m_cmd_read_addr_fifo.read()];
     2264          r_read_to_cleanup_cached_read = (m_cmd_read_pktid_fifo.read() & 0x1);
     2265          r_read_to_cleanup_addr = m_cmd_read_addr_fifo.read();
     2266          r_read_to_cleanup_is_ll= ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL);
     2267          r_read_to_cleanup_ll_key = r_read_ll_key.read();
     2268          //std::cout << "cleanup req (read) on line " << nline << " /on proc " << r_read_copy.read() << std::endl;
     2269
     2270          m_upt.set(false,  // it's an inval transaction
     2271                          false,     // it's not a broadcast
     2272                          false,     // it needs a read response
     2273                          false,     // no acknowledge required
     2274                          m_cmd_read_srcid_fifo.read(),
     2275                          m_cmd_read_trdid_fifo.read(),
     2276                          m_cmd_read_pktid_fifo.read(),
     2277                          nline,
     2278                          0x1, //Expect only one answer
     2279                          index);
     2280
     2281          cmd_read_fifo_get = true;
     2282          r_read_fsm = READ_IDLE;
     2283#if DEBUG_MEMC_READ
     2284        if(m_debug)
     2285        {
     2286          std::cout
     2287              << "  <MEMC " << name() << " READ_IVT_LOCK>"
     2288              << " Inval req on an NCC line"
     2289              << std::endl;
     2290        }
     2291#endif
     2292        }
     2293      }
     2294
     2295
     2296      break;
     2297    }
     2298
    19672299    //////////////////
     2300        case READ_WAIT://Release the locks
     2301        {
     2302            r_read_fsm = READ_DIR_REQ;
     2303#if DEBUG_MEMC_READ
     2304        if(m_debug)
     2305        {
     2306          std::cout
     2307              << "  <MEMC " << name() << " READ_WAIT>" << std::endl;
     2308        }
     2309#endif
     2310        break;
     2311        }
     2312    ///////////////////                     
    19682313    case READ_DIR_HIT:    //  read data in cache & update the directory
    19692314                          //  we enter this state in 3 cases:
     
    19962341        DirectoryEntry entry;
    19972342        entry.valid   = true;
     2343        entry.cache_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
     2344        r_read_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
    19982345        entry.is_cnt  = is_cnt;
    19992346        entry.dirty   = r_read_dirty.read();
     
    20012348        entry.lock    = r_read_lock.read();
    20022349        entry.ptr     = r_read_ptr.read();
    2003 
    20042350        if(cached_read)   // Cached read => we must update the copies
    20052351        {
     
    20342380
    20352381#if DEBUG_MEMC_READ
    2036         if(m_debug)
    2037           std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    2038             << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
    2039             << " / set = " << std::dec << set
    2040             << " / way = " << way
    2041             << " / owner_id = " << std::hex << entry.owner.srcid
    2042             << " / owner_ins = " << std::dec << entry.owner.inst
    2043             << " / count = " << entry.count
    2044             << " / is_cnt = " << entry.is_cnt << std::endl;
     2382if(m_debug)
     2383std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
     2384          << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
     2385          << " / set = " << std::dec << set
     2386          << " / way = " << way
     2387          << " / owner_id = " << std::hex << entry.owner.srcid
     2388          << " / owner_ins = " << std::dec << entry.owner.inst
     2389          << " / coherent = " << entry.cache_coherent
     2390          << " / count = " << entry.count
     2391          << " / is_cnt = " << entry.is_cnt << std::endl;
    20452392#endif
    20462393
     
    20562403      {
    20572404        r_read_fsm = READ_HEAP_LOCK;
     2405        m_cpt_read_fsm_n_heap_lock++;
    20582406      }
    20592407
     
    20632411          << " Requesting HEAP lock " << std::endl;
    20642412#endif
     2413
     2414      m_cpt_read_fsm_heap_lock++;
     2415
    20652416      break;
    20662417    }
     
    20752426        bool go_cnt = (r_read_count.read() >= m_max_copies) or m_heap.is_full();
    20762427
     2428        if (!r_read_coherent.read())
     2429        {
     2430          std::cout << "Address = " << std::hex << (m_cmd_read_addr_fifo.read()) << std::dec << " |count = " << r_read_count.read() << std::endl;
     2431        }
     2432        assert (r_read_coherent.read() && "accÚs au heap sur ncc");
    20772433        // read data in the cache
    20782434        size_t set = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
     
    20862442        DirectoryEntry entry;
    20872443        entry.valid  = true;
     2444        entry.cache_coherent = r_read_coherent.read();
    20882445        entry.is_cnt = go_cnt;
    20892446        entry.dirty  = r_read_dirty.read();
     
    22722629        r_read_to_tgt_rsp_length = m_cmd_read_length_fifo.read();
    22732630        r_read_to_tgt_rsp_srcid  = m_cmd_read_srcid_fifo.read();
     2631        /*RWT*/
     2632        //BUG pktid
     2633        if (r_read_coherent.read())
     2634        {
     2635          r_read_to_tgt_rsp_pktid = 0x0 + m_cmd_read_pktid_fifo.read();
     2636          //std::cout << "READ RSP COHERENT on word" << std::hex << m_x[(addr_t) m_cmd_read_addr_fifo.read()] << std::dec << std::endl;
     2637        }
     2638        else
     2639        {
     2640          r_read_to_tgt_rsp_pktid = 0x8 + m_cmd_read_pktid_fifo.read();
     2641        }
    22742642        r_read_to_tgt_rsp_trdid  = m_cmd_read_trdid_fifo.read();
    2275         r_read_to_tgt_rsp_pktid  = m_cmd_read_pktid_fifo.read();
    22762643        r_read_to_tgt_rsp_ll_key = r_read_ll_key.read();
    22772644        cmd_read_fifo_get        = true;
     
    23022669        if(hit_read or !wok or hit_write)    // missing line already requested or no space
    23032670        {
    2304           if(!wok)      m_cpt_trt_full++;
     2671          if(!wok)
     2672          {
     2673            m_cpt_trt_full++;
     2674          }
    23052675          if(hit_read or hit_write)   m_cpt_trt_rb++;
    23062676          r_read_fsm = READ_IDLE;
     
    23192689          << " / hit_write = " << hit_write
    23202690          << " / full = " << !wok << std::endl;
    2321 #endif
    2322       }
     2691        m_cpt_read_fsm_n_trt_lock++;
     2692#endif
     2693      }
     2694
     2695      m_cpt_read_fsm_trt_lock++;
     2696
    23232697      break;
    23242698    }
     
    23412715                              std::vector<data_t> (m_words,0),
    23422716                              r_read_ll_key.read());
     2717       
    23432718#if DEBUG_MEMC_READ
    23442719if(m_debug)
     
    25072882      {
    25082883        ///////////////////////////////////////////////////////////////////////
    2509         // SC command treatment
     2884        // SC command handling
    25102885        // We test the r_write_pending_sc register to know if we are returning
    25112886        // from the WAIT state.
     
    25132888        // another time from the FIFO. Also, we don't have to test another
    25142889        // time if the SC has succeed
     2890
     2891        addr_t nline = m_nline[(addr_t)(r_write_address.read())];
    25152892        if(((r_write_pktid.read() & 0x7) == TYPE_SC) and not r_write_pending_sc.read())
    25162893        {
    25172894          if(not m_cmd_write_addr_fifo.rok()) break;
    2518 
     2895 
    25192896          assert(m_cmd_write_eop_fifo.read() and
    25202897                 "Error in VCI_MEM_CACHE : "
    25212898                 "invalid packet format for SC command");
    2522 
     2899          //BUG LLSC
    25232900          size_t index    = r_write_word_index.read();
    2524           bool sc_success = m_llsc_table.sc(r_write_address.read()    ,
     2901          bool sc_success = m_llsc_table.sc(nline    ,
    25252902                                            r_write_data[index].read());
    2526 
     2903 
     2904          //bool sc_success = m_llsc_table.sc(r_write_address.read()    ,
     2905          //                                  r_write_data[index].read());
    25272906          // consume a word in the FIFO & write it in the local buffer
    25282907          cmd_write_fifo_get  = true;
    25292908          r_write_data[index] = m_cmd_write_data_fifo.read();
    25302909          r_write_sc_fail     = not sc_success;
     2910          //WARNING: if the SC is a success, it might still fail at next cycle if the line is NCC
    25312911          r_write_pending_sc  = true;
    2532 
     2912 
    25332913          if(not sc_success) r_write_fsm = WRITE_RSP;
    25342914          else               r_write_fsm = WRITE_DIR_LOCK;
    2535 
     2915 
    25362916          break;
    25372917        }
    2538 
     2918 
    25392919        ///////////////////////////////////////////////////////////////////////
    25402920        // WRITE command treatment or SC command returning from the WAIT state
     
    25422922        // erase any possible new reservation when we release the lock on the
    25432923        // directory
    2544         m_llsc_table.sw(r_write_address.read());
     2924        m_llsc_table.sw(nline);
     2925
     2926        //m_llsc_table.sw(r_write_address.read());
    25452927
    25462928        r_write_fsm = WRITE_DIR_LOCK;
     2929        m_cpt_write_fsm_n_dir_lock++;
    25472930      }
    25482931
     
    25522935          << std::endl;
    25532936#endif
     2937
     2938      m_cpt_write_fsm_dir_lock++;
    25542939
    25552940      break;
     
    25782963          r_write_ptr        = entry.ptr;
    25792964          r_write_way        = way;
    2580 
    2581           if(entry.is_cnt and entry.count)
     2965         
     2966          r_write_coherent   = entry.cache_coherent;
     2967
     2968          if (entry.cache_coherent or (entry.owner.srcid == r_write_srcid.read()) or (entry.count == 0)) // hit WT
    25822969          {
    2583             r_write_fsm = WRITE_DIR_READ;
     2970            if(entry.is_cnt && entry.count)
     2971            {
     2972              r_write_fsm = WRITE_DIR_READ;
     2973            }
     2974            else
     2975            {
     2976             r_write_fsm = WRITE_DIR_HIT;
     2977            }
    25842978          }
    25852979          else
    25862980          {
    2587             r_write_fsm = WRITE_DIR_HIT;
     2981            if (r_write_to_cleanup_req.read())//inval already sent
     2982            {
     2983              r_write_fsm = WRITE_WAIT;
     2984            }
     2985            else // hit on a NCC line with a different owner
     2986            {
     2987              r_write_fsm = WRITE_IVT_LOCK_HIT_WB;
     2988              if(r_write_pktid.read() == TYPE_SC)
     2989              {
     2990                r_write_sc_fail = true;
     2991              }
     2992            }
    25882993          }
    25892994        }
    25902995        else  // miss
    25912996        {
    2592           r_write_fsm = WRITE_MISS_TRT_LOCK;
     2997          r_write_fsm = WRITE_MISS_IVT_LOCK;
    25932998        }
    25942999
     
    26193024    }
    26203025    ////////////////////
     3026    case WRITE_IVT_LOCK_HIT_WB:
     3027    {
     3028      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
     3029      {
     3030
     3031        size_t index = 0;
     3032        bool   match_inval;
     3033        addr_t nline = m_nline[(addr_t)(r_write_address.read())];
     3034
     3035        //std::cout << "WRITE on NCC on line" << std::hex << nline << std::dec << std::endl;
     3036
     3037        match_inval = m_upt.search_inval(nline, index);
     3038        assert ((r_write_count.read() == 1) and "NCC to CC req without copy");
     3039        if(!match_inval and !r_write_to_cc_send_req.read())
     3040        {
     3041          r_write_to_cc_send_req = true;
     3042          r_write_to_cc_send_dest = r_write_copy;
     3043          r_write_to_cc_send_nline = nline;
     3044          r_write_to_cleanup_req = true;
     3045          r_write_to_cleanup_nline = nline;
     3046
     3047          m_upt.set(false,  // it's an inval transaction
     3048                          false,     // it's not a broadcast
     3049                          true,      // it needs no read response
     3050                          false,     // no acknowledge required
     3051                          m_cmd_write_srcid_fifo.read(), //never read, used for debug
     3052                          m_cmd_write_trdid_fifo.read(), //never read, used for debug
     3053                          m_cmd_write_pktid_fifo.read(), //never read, used for debug
     3054                          nline,
     3055                          0x1, //Expect only one answer
     3056                          index);
     3057        }
     3058        r_write_fsm = WRITE_WAIT;
     3059#if DEBUG_MEMC_WRITE
     3060        if(m_debug)
     3061        {
     3062          std::cout << "  <MEMC " << name() << " WRITE_IVT_LOCK_HIT_WB> get access to the UPT: "
     3063                    << " Inval requested =  " << (!match_inval and !r_write_to_cc_send_req.read())
     3064                    << std::endl;
     3065        }
     3066#endif
     3067      }
     3068#if DEBUG_MEMC_WRITE
     3069        if(m_debug)
     3070        {
     3071          std::cout << "  <MEMC " << name() << " WRITE_IVT_LOCK_HIT_WB> failed to access to the UPT: "
     3072                    << std::endl;
     3073        }
     3074#endif
     3075      break;
     3076    }
     3077
     3078
     3079    ////////////////////
    26213080    case WRITE_DIR_READ:  // read the cache and complete the buffer when be!=0xF
    26223081    {
     
    26563115      DirectoryEntry entry;
    26573116      entry.valid          = true;
     3117      entry.cache_coherent = r_write_coherent.read();
    26583118      entry.dirty          = true;
    26593119      entry.tag            = r_write_tag.read();
     
    26833143      // no_update is true when there is no need for coherence transaction
    26843144      // (tests for sc requests)
    2685       bool no_update = ( (r_write_count.read() == 0) or
    2686                          (owner and (r_write_count.read() ==1) and
    2687                          (r_write_pktid.read() != TYPE_SC)));
     3145      bool no_update = ((r_write_count.read() ==0) || //no need for coherency
     3146                        (owner && (r_write_count.read() ==1) && (r_write_pktid.read() != TYPE_SC)) || //writer is owner
     3147                        ((r_write_pktid.read() == TYPE_SC) && r_write_sc_fail.read())); //SC failed: no data update
    26883148
    26893149      // write data in the cache if no coherence transaction
    2690       if(no_update)
     3150      if(no_update and ((r_write_pktid.read() != TYPE_SC) or !r_write_sc_fail.read()))
    26913151      {
    26923152        for(size_t word=0 ; word<m_words ; word++)
     
    27603220        size_t      set        = m_y[(addr_t)(r_write_address.read())];
    27613221        size_t      way        = r_write_way.read();
     3222
    27623223
    27633224        wok = m_upt.set(true,  // it's an update transaction
     
    28043265        if(wok) r_write_fsm = WRITE_UPT_HEAP_LOCK;
    28053266        else    r_write_fsm = WRITE_WAIT;
    2806       }
     3267        m_cpt_write_fsm_n_upt_lock++;
     3268      }
     3269
     3270      m_cpt_write_fsm_upt_lock++;
     3271
    28073272      break;
    28083273    }
     
    28203285#endif
    28213286        r_write_fsm = WRITE_UPT_REQ;
    2822       }
     3287        m_cpt_write_fsm_n_heap_lock++;
     3288      }
     3289
     3290      m_cpt_write_fsm_heap_lock++;
     3291
    28233292      break;
    28243293    }
     
    28343303             "transaction in WRITE_UPT_REQ state"
    28353304            );
     3305
    28363306
    28373307      r_write_to_cc_send_brdcast_req  = false;
     
    30703540      break;
    30713541    }
     3542    ///////////////////////// RWT
     3543    case WRITE_MISS_IVT_LOCK: // Miss : check UPT
     3544    {
     3545      if (r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
     3546      {
     3547        size_t index;
     3548        if(m_upt.search_inval(m_nline[(addr_t)(r_write_address.read())], index))
     3549        {
     3550          r_write_fsm = WRITE_WAIT;
     3551        }
     3552        else
     3553        {
     3554          r_write_fsm = WRITE_MISS_TRT_LOCK;
     3555        }
     3556      }
     3557      break;
     3558    }
    30723559
    30733560    /////////////////////////
     
    30873574        bool    hit_write = m_trt.hit_write(m_nline[addr]);
    30883575        bool    wok       = !m_trt.full(wok_index);
    3089 
     3576        //std::cout << "MEMCACHE : WRITE MISS at " << std::hex << (uint32_t)addr << std::dec << std::endl;
    30903577        if(hit_read)      // register the modified data in TRT
    30913578        {
     
    31053592          m_cpt_trt_full++;
    31063593        }
    3107       }
     3594        m_cpt_write_fsm_n_trt_lock++;
     3595      }
     3596
     3597      m_cpt_write_fsm_trt_lock++;
     3598
    31083599      break;
    31093600    }
     
    32243715          << " : wok = " << wok << " / index = " << wok_index << std::endl;
    32253716#endif
    3226       }
     3717        m_cpt_write_fsm_n_trt_lock++;
     3718      }
     3719
     3720      m_cpt_write_fsm_trt_lock++;
     3721
    32273722      break;
    32283723    }
     
    32513746                        nb_copies,
    32523747                        index);
    3253 
     3748       /*ODCCP*/ //m_upt.print();
    32543749#if DEBUG_MEMC_WRITE
    32553750if( m_debug and wok )
     
    32613756        if(wok) r_write_fsm = WRITE_BC_DIR_INVAL;
    32623757        else    r_write_fsm = WRITE_WAIT;
    3263       }
     3758        m_cpt_write_fsm_n_upt_lock++;
     3759      }
     3760
     3761      m_cpt_write_fsm_upt_lock++;
     3762
    32643763      break;
    32653764    }
     
    32953794      DirectoryEntry entry;
    32963795      entry.valid         = false;
     3796      entry.cache_coherent= false;
    32973797      entry.dirty         = false;
    32983798      entry.tag         = 0;
     
    33943894    ////////////////////////
    33953895    case IXR_CMD_READ_IDLE:
    3396     {
    33973896      if     (r_write_to_ixr_cmd_req)    r_ixr_cmd_fsm = IXR_CMD_WRITE;
    33983897      else if(r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
    33993898      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3899      else if(r_cleanup_to_ixr_cmd_req)  r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
    34003900      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    34013901      break;
    3402     }
    34033902    ////////////////////////
    34043903    case IXR_CMD_WRITE_IDLE:
    3405     {
    3406       if     (r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
     3904      if(r_cas_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CAS;
    34073905      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3906      else if(r_cleanup_to_ixr_cmd_req)  r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
    34083907      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    34093908      else if(r_write_to_ixr_cmd_req)    r_ixr_cmd_fsm = IXR_CMD_WRITE;
    34103909      break;
    3411     }
    34123910    ////////////////////////
    34133911    case IXR_CMD_CAS_IDLE:
    3414     {
    3415       if     (r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3912      if(r_xram_rsp_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3913      else if(r_cleanup_to_ixr_cmd_req)  r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
    34163914      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    34173915      else if(r_write_to_ixr_cmd_req)    r_ixr_cmd_fsm = IXR_CMD_WRITE;
    34183916      else if(r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
    34193917      break;
    3420     }
    34213918    ////////////////////////
    34223919    case IXR_CMD_XRAM_IDLE:
    3423     {
    3424       if     (r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
    3425       else if(r_write_to_ixr_cmd_req)    r_ixr_cmd_fsm = IXR_CMD_WRITE;
     3920      if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3921      else if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
     3922      else if(r_write_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_WRITE;
    34263923      else if(r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
    34273924      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
    34283925      break;
    3429     }
     3926      ////////////////////////
     3927    case IXR_CMD_CLEANUP_IDLE:
     3928      /*ODCCP*///std::cout << "IXR_CMD_CLEANUP_IDLE" << std::endl;
     3929      if(r_read_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_READ;
     3930      else if(r_write_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_WRITE;
     3931      else if(r_cas_to_ixr_cmd_req)      r_ixr_cmd_fsm = IXR_CMD_CAS;
     3932      else if(r_xram_rsp_to_ixr_cmd_req) r_ixr_cmd_fsm = IXR_CMD_XRAM;
     3933      else if(r_cleanup_to_ixr_cmd_req)     r_ixr_cmd_fsm = IXR_CMD_CLEANUP_DATA;
     3934      break;     
    34303935    //////////////////       // send a get from READ FSM
    34313936    case IXR_CMD_READ:
     
    35534058      break;
    35544059    }
     4060
     4061      ////////////////////////
     4062    case IXR_CMD_CLEANUP_DATA:     // send a put command to XRAM
     4063      /*ODCCP*///std::cout << "IXR_CMD_CLEANUP_DATA" << std::endl;
     4064      if(p_vci_ixr.cmdack)
     4065      {
     4066        if(r_ixr_cmd_cpt.read() == (m_words - 2))
     4067        {
     4068          r_ixr_cmd_cpt = 0;
     4069          r_ixr_cmd_fsm = IXR_CMD_CLEANUP_IDLE;
     4070          r_xram_rsp_to_ixr_cmd_inval_ncc_pending = false;
     4071          r_cleanup_to_ixr_cmd_req = false;
     4072        }
     4073        else
     4074        {
     4075          r_ixr_cmd_cpt = r_ixr_cmd_cpt.read() + 2;
     4076        }
     4077
     4078#if DEBUG_MEMC_IXR_CMD
     4079        if(m_debug)
     4080        {
     4081          std::cout << "  <MEMC " << name() << ".IXR_CMD_CLEANUP_DATA> Send a put request to xram" << std::endl;
     4082        }
     4083#endif
     4084      }
     4085      break;
    35554086
    35564087  } // end switch r_ixr_cmd_fsm
     
    36314162          << r_ixr_rsp_trt_index.read() << std::endl;
    36324163#endif
    3633       }
     4164      m_cpt_ixr_fsm_n_trt_lock++;
     4165      }
     4166
     4167      m_cpt_ixr_fsm_trt_lock++;
     4168
    36344169      break;
    36354170    }
     
    36674202          << " / data = " << std::hex << data << std::endl;
    36684203#endif
    3669       }
     4204      m_cpt_ixr_fsm_n_trt_lock++;
     4205      }
     4206      m_cpt_ixr_fsm_trt_lock++;
    36704207      break;
    36714208    }
     
    37404277          << " Get access to DIR and TRT" << std::endl;
    37414278#endif
    3742       }
     4279        m_cpt_xram_rsp_fsm_n_dir_lock++;
     4280        m_cpt_xram_rsp_fsm_n_trt_lock++;
     4281      }
     4282      m_cpt_xram_rsp_fsm_dir_lock++;
     4283      m_cpt_xram_rsp_fsm_trt_lock++;
    37434284      break;
    37444285    }
     
    37564297        DirectoryEntry victim(m_cache_directory.select(set, way));
    37574298
    3758         bool inval = (victim.count and victim.valid) ;
     4299        bool inval = (victim.count && victim.valid) or (!victim.cache_coherent and (victim.count == 1)) ;
     4300
    37594301
    37604302        // copy the victim line in a local buffer
     
    37664308        r_xram_rsp_victim_copy_cache= victim.owner.cache_id;
    37674309#endif
     4310        r_xram_rsp_victim_coherent  = victim.cache_coherent;
    37684311        r_xram_rsp_victim_copy_inst = victim.owner.inst;
    37694312        r_xram_rsp_victim_count     = victim.count;
     
    37744317        r_xram_rsp_victim_is_cnt    = victim.is_cnt;
    37754318        r_xram_rsp_victim_inval     = inval ;
    3776         r_xram_rsp_victim_dirty     = victim.dirty;
     4319        r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1)); //a NCC line is by default considered as dirty in the L1: we must take a reservation on a TRT entry
     4320
    37774321
    37784322        if(!r_xram_rsp_trt_buf.rerror)
    37794323        {
    3780           r_xram_rsp_fsm = XRAM_RSP_INVAL_LOCK;
     4324          if (!victim.cache_coherent and r_xram_rsp_to_ixr_cmd_inval_ncc_pending.read()) //there can not be two L2 invalidation on NCC line at the same time
     4325          {
     4326            r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     4327          }
     4328          else
     4329          {
     4330            r_xram_rsp_fsm = XRAM_RSP_INVAL_LOCK;
     4331          }
    37814332        }
    37824333        else
     
    38084359      {
    38094360        size_t index = 0;
    3810         if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
     4361        size_t index_victim = 0;
     4362        if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index) or
     4363           m_ivt.search_inval(r_xram_rsp_victim_nline.read(), index_victim))
    38114364        {
    38124365          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    38244377        {
    38254378          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     4379          m_upt.print();
    38264380
    38274381#if DEBUG_MEMC_XRAM_RSP
     
    38414395#endif
    38424396        }
    3843       }
     4397        m_cpt_xram_rsp_fsm_n_upt_lock++;
     4398      }
     4399
     4400      m_cpt_xram_rsp_fsm_upt_lock++;
     4401
    38444402      break;
    38454403    }
     
    38914449      DirectoryEntry entry;
    38924450      entry.valid   = true;
     4451      entry.cache_coherent = (inst_read or (not(cached_read))) and (r_xram_rsp_trt_buf.proc_read);
    38934452      entry.is_cnt  = false;
    38944453      entry.lock    = false;
     
    39074466      else
    39084467      {
    3909         entry.owner.srcid    = 0;
     4468        entry.owner.srcid    = r_xram_rsp_trt_buf.srcid;
    39104469#if L1_MULTI_CACHE
    39114470        entry.owner.cache_id = 0;
     
    39154474      }
    39164475      m_cache_directory.write(set, way, entry);
    3917 
     4476      //RWT: keep the coherence information in order to send it to the read_rsp
     4477      r_xram_rsp_coherent = inst_read or (not(cached_read));
    39184478      // request an invalidattion request in IVT for victim line
    39194479      if(r_xram_rsp_victim_inval.read())
     
    39224482        size_t index        = 0;
    39234483        size_t count_copies = r_xram_rsp_victim_count.read();
    3924 
     4484 
    39254485        bool   wok = m_ivt.set(false,      // it's an inval transaction
    39264486                               broadcast,  // set broadcast bit
     
    39354495
    39364496        r_xram_rsp_ivt_index = index;
    3937 
    39384497        if(!wok)
    39394498        {
     
    39434502        }
    39444503      }
    3945 
     4504      if (!r_xram_rsp_victim_coherent.read())
     4505      {
     4506        //m_llsc_table.sw(r_xram_rsp_victim_nline.read()*m_words*4);
     4507        m_llsc_table.sw(r_xram_rsp_victim_nline.read());
     4508      }
    39464509#if DEBUG_MEMC_XRAM_RSP
    39474510if(m_debug)
     
    39624525#endif
    39634526
    3964       // If the victim is not dirty, we don't need another XRAM put transaction,
     4527      // If the victim is not dirty (RWT: if it is not coherent, we can not know wether it is dirty or not), we don't need another XRAM put transaction,
    39654528      // and we can erase the TRT entry
    3966       if(!r_xram_rsp_victim_dirty.read())  m_trt.erase(r_xram_rsp_trt_index.read());
     4529      if(!r_xram_rsp_victim_dirty.read() and (r_xram_rsp_victim_coherent.read() or (r_xram_rsp_victim_count.read() == 0)))  m_trt.erase(r_xram_rsp_trt_index.read());
    39674530
    39684531      // Next state
    3969       if(r_xram_rsp_victim_dirty.read())       r_xram_rsp_fsm = XRAM_RSP_TRT_DIRTY;
     4532      if(r_xram_rsp_victim_dirty.read() or (!r_xram_rsp_victim_coherent.read() and (r_xram_rsp_victim_count.read() == 1)))       r_xram_rsp_fsm = XRAM_RSP_TRT_DIRTY;
    39704533      else if(r_xram_rsp_trt_buf.proc_read)    r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
    39714534      else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
     
    39744537    }
    39754538    ////////////////////////
    3976     case XRAM_RSP_TRT_DIRTY:  // set the TRT entry (PUT to XRAM) if the victim is dirty
     4539    case XRAM_RSP_TRT_DIRTY:  // set the TRT entry (write to XRAM) if the victim is dirty or not coherent (RWT)
    39774540    {
    39784541      if(r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP)
    39794542      {
     4543
    39804544        m_trt.set(r_xram_rsp_trt_index.read(),
    39814545                              false,       // write to XRAM
     
    39994563        else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
    40004564        else                                     r_xram_rsp_fsm = XRAM_RSP_WRITE_DIRTY;
    4001       }
     4565        m_cpt_xram_rsp_fsm_n_trt_lock++;
     4566      }
     4567
     4568      m_cpt_xram_rsp_fsm_trt_lock++;
     4569
    40024570      break;
    40034571    }
     
    40094577        r_xram_rsp_to_tgt_rsp_srcid = r_xram_rsp_trt_buf.srcid;
    40104578        r_xram_rsp_to_tgt_rsp_trdid = r_xram_rsp_trt_buf.trdid;
    4011         r_xram_rsp_to_tgt_rsp_pktid = r_xram_rsp_trt_buf.pktid;
     4579        if (r_xram_rsp_coherent.read())
     4580        {
     4581          r_xram_rsp_to_tgt_rsp_pktid = 0x0 + r_xram_rsp_trt_buf.pktid;//RWT CC
     4582        }
     4583        else
     4584        {
     4585          r_xram_rsp_to_tgt_rsp_pktid = 0x8 + r_xram_rsp_trt_buf.pktid;//RWT NCC
     4586        }
    40124587        for(size_t i=0; i < m_words; i++)
    40134588        {
     
    40194594        r_xram_rsp_to_tgt_rsp_rerror = false;
    40204595        r_xram_rsp_to_tgt_rsp_req    = true;
     4596     
    40214597
    40224598        if(r_xram_rsp_victim_inval)      r_xram_rsp_fsm = XRAM_RSP_INVAL;
     
    40734649    case XRAM_RSP_WRITE_DIRTY:  // send a write request to IXR_CMD FSM
    40744650    {
    4075       if(!r_xram_rsp_to_ixr_cmd_req.read())
     4651      if(!r_xram_rsp_to_ixr_cmd_req.read() and !r_xram_rsp_to_ixr_cmd_inval_ncc_pending.read())
    40764652      {
    40774653        r_xram_rsp_to_ixr_cmd_req = true;
     
    40814657        {
    40824658            r_xram_rsp_to_ixr_cmd_data[i] = r_xram_rsp_victim_data[i];
     4659              std::cout << "data L2 = " << std::hex << r_xram_rsp_victim_data[i] << std::dec << std::endl;
    40834660        }
    40844661        m_cpt_write_dirty++;
     4662       
     4663        if ((!r_xram_rsp_victim_coherent.read()) and (r_xram_rsp_victim_count.read() == 1)) //if NCC, we save the data in case of not dirty L1
     4664        {
     4665          r_xram_rsp_to_ixr_cmd_req = false;
     4666          r_xram_rsp_to_ixr_cmd_inval_ncc_pending = true;
     4667          r_xram_rsp_fsm = XRAM_RSP_IDLE;
     4668          break;
     4669        }
    40854670
    40864671        bool multi_req = !r_xram_rsp_victim_is_cnt.read() and r_xram_rsp_victim_inval.read();
     
    41054690      {
    41064691        r_xram_rsp_fsm = XRAM_RSP_HEAP_ERASE;
     4692        m_cpt_xram_rsp_fsm_n_heap_lock++;
    41074693      }
    41084694
     
    41124698          << " Requesting HEAP lock" << std::endl;
    41134699#endif
     4700
     4701      m_cpt_xram_rsp_fsm_heap_lock++;
     4702
    41144703      break;
    41154704    }
     
    42784867      r_cleanup_inst  = (type == DspinDhccpParam::TYPE_CLEANUP_INST);
    42794868      r_cleanup_srcid = srcid;
     4869      r_cleanup_ncc =
     4870        DspinDhccpParam::dspin_get(
     4871            flit,
     4872            DspinDhccpParam::CLEANUP_NCC);
     4873      r_cleanup_contains_data = false;
    42804874
    42814875      if(srcid >= m_initiators)
     
    42944888
    42954889#if DEBUG_MEMC_CLEANUP
    4296 if(m_debug)
    4297 std::cout << "  <MEMC "         << name()
    4298           << " CLEANUP_IDLE> Cleanup request:" << std::hex
    4299           << " / owner_id = "   << srcid
    4300           << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST) << std::endl;
     4890      if(m_debug)
     4891      {
     4892        std::cout
     4893            << "  <MEMC "         << name()
     4894            << " CLEANUP_IDLE> Cleanup request:" << std::hex
     4895            << " / owner_id = "   << srcid
     4896            << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST)
     4897            << " / ncc = " << DspinDhccpParam::dspin_get(
     4898                                                          flit,
     4899                                                          DspinDhccpParam::CLEANUP_NCC)
     4900            << std::endl;
     4901      }
    43014902#endif
    43024903      break;
     
    43124913      addr_t nline = r_cleanup_nline.read() |
    43134914        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB);
    4314 
     4915     
     4916      //A MODIFIER POUR DIRTY //
     4917      bool eop =
     4918        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     4919      if (! eop)
     4920      {
     4921        r_cleanup_fsm = CLEANUP_GET_DATA;
     4922        r_cleanup_data_index = 0;
     4923        r_cleanup_contains_data = true;
     4924      }
     4925      else
     4926      {
     4927        r_cleanup_fsm = CLEANUP_DIR_REQ;
     4928      }
    43154929      cc_receive_to_cleanup_fifo_get = true;
    4316       r_cleanup_nline                = nline;
    4317       r_cleanup_fsm                  = CLEANUP_DIR_REQ;
     4930      r_cleanup_nline               = nline;
    43184931
    43194932#if DEBUG_MEMC_CLEANUP
    4320 if(m_debug)
    4321 std::cout << "  <MEMC "         << name()
    4322           << " CLEANUP_GET_NLINE> Cleanup request:"
    4323           << " / address = " << std::hex << nline * m_words * 4 << std::endl;
    4324 #endif
    4325       break;
    4326     }
    4327 
     4933      if(m_debug)
     4934      {
     4935        std::cout
     4936            << "  <MEMC "         << name()
     4937            << " CLEANUP_GET_NLINE> Cleanup request:"
     4938            << std::hex
     4939            << " / address = "    << nline * m_words * 4
     4940            << " / contains data = " << (!eop)
     4941            << std::endl;
     4942      }
     4943#endif
     4944      break;
     4945    }
     4946    /////////////////////
     4947    case CLEANUP_GET_DATA :
     4948    {
     4949      if (m_cc_receive_to_cleanup_fifo.rok())
     4950      {
     4951        uint64_t flit = m_cc_receive_to_cleanup_fifo.read();
     4952 
     4953        uint32_t data =
     4954          DspinDhccpParam::dspin_get (flit, DspinDhccpParam::CLEANUP_DATA_UPDT);
     4955 
     4956        r_cleanup_data[r_cleanup_data_index] = data;
     4957        r_cleanup_data_index = r_cleanup_data_index.read() + 1;
     4958        assert (r_cleanup_data_index.read() < m_words and "MEM_CACHE in CLEANUP_GET_DATA : too much flits in cleanup data updt");
     4959        cc_receive_to_cleanup_fifo_get = true;
     4960        if (r_cleanup_data_index.read() == m_words - 1)
     4961        {
     4962          r_cleanup_contains_data = true;
     4963          m_cpt_cleanup_data ++;
     4964          r_cleanup_fsm = CLEANUP_DIR_REQ;
     4965        }
     4966#if DEBUG_MEMC_CLEANUP
     4967      if(m_debug)
     4968      {
     4969        std::cout
     4970            << "  <MEMC "         << name()
     4971            << " CLEANUP_GET_DATA> "
     4972            << " / word = "    << std::dec << r_cleanup_data_index.read()
     4973            << " / data = " << std::hex << data
     4974            << std::endl;
     4975      }
     4976#endif
     4977      }
     4978      break;
     4979    }
    43284980    /////////////////////
    43294981    case CLEANUP_DIR_REQ:   // Get the lock to the directory
    43304982    {
     4983      m_cpt_cleanup_fsm_dir_lock++;
    43314984      if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP) break;
    43324985
    43334986      r_cleanup_fsm = CLEANUP_DIR_LOCK;
     4987      //std::cout << " MEM_CACHE : CLEANUP_DIR_REQ" << std::endl;
    43344988
    43354989#if DEBUG_MEMC_CLEANUP
     
    43374991std::cout << "  <MEMC " << name() << " CLEANUP_DIR_REQ> Requesting DIR lock" << std::endl;
    43384992#endif
     4993
     4994      m_cpt_cleanup_fsm_n_dir_lock++;
     4995
    43394996      break;
    43404997    }
     
    43535010        exit(0);
    43545011      }
     5012      //std::cout << " MEM_CACHE : CLEANUP_DIR_LOCK" << std::endl;
    43555013
    43565014      // Read the directory
     
    43715029      r_cleanup_copy_cache   = entry.owner.cache_id;
    43725030#endif
     5031
     5032      //RWT
     5033      size_t set = m_y[(addr_t)(cleanup_address)];
     5034      m_cache_data.read_line(way, set, r_cleanup_old_data);
     5035      r_cleanup_coherent = entry.cache_coherent;
     5036
     5037
    43735038
    43745039      if(entry.valid)      // hit : the copy must be cleared
     
    44205085    case CLEANUP_DIR_WRITE:
    44215086    {
     5087      /*ODCCP*///std::cout << "CLEANUP_DIR_WRITE" << std::endl;
    44225088      // Update the directory entry without heap access
    44235089      if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP)
     
    44535119      }
    44545120
     5121      /*RWT*/
     5122      bool   inval_request = (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) // NCC to CC initiated by a read transaction
     5123                          or (r_write_to_cleanup_req.read() and (r_cleanup_nline.read() == r_write_to_cleanup_nline.read())); //NCC to CC initiated by a wrtie transaction
     5124
     5125
     5126      if (inval_request) m_cpt_ncc_to_cc ++;
     5127
     5128      if (r_write_to_cleanup_req.read() and (r_cleanup_nline.read() == r_write_to_cleanup_nline.read()))
     5129      {
     5130        r_write_to_cleanup_req = false;
     5131        m_cpt_ncc_to_cc_write ++;
     5132      }
     5133
     5134
    44555135      // update the cache directory (for the copies)
    44565136      DirectoryEntry entry;
    4457       entry.valid       = true;
    4458       entry.is_cnt      = r_cleanup_is_cnt.read();
    4459       entry.dirty       = r_cleanup_dirty.read();
    4460       entry.tag         = r_cleanup_tag.read();
    4461       entry.lock        = r_cleanup_lock.read();
    4462       entry.ptr         = r_cleanup_ptr.read();
    4463       entry.count       = r_cleanup_count.read() - 1;
    4464       entry.owner.srcid = 0;
    4465       entry.owner.inst  = 0;
    4466 
     5137      entry.valid          = true;
     5138      entry.cache_coherent = inval_request or r_cleanup_coherent.read();
     5139      entry.is_cnt         = r_cleanup_is_cnt.read();
     5140      entry.dirty          = r_cleanup_dirty.read() or r_cleanup_contains_data.read();
     5141      entry.tag            = r_cleanup_tag.read();
     5142      entry.lock           = r_cleanup_lock.read();
     5143      entry.ptr            = r_cleanup_ptr.read();
     5144      if (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) //pending READ
     5145      {
     5146        if (r_read_to_cleanup_cached_read.read())
     5147        {
     5148          entry.count          = r_cleanup_count.read();
     5149          entry.owner.srcid    = r_read_to_cleanup_srcid.read();
     5150          entry.owner.inst     = 0;
    44675151#if L1_MULTI_CACHE
    4468       entry.owner.cache_id = 0;
    4469 #endif
     5152          entry.owner.cache_id = r_cleanup_copy_cache.read();
     5153#endif
     5154        }
     5155        else
     5156        {
     5157          entry.count          = r_cleanup_count.read() - 1;
     5158          entry.owner.srcid    = r_cleanup_copy.read();
     5159          entry.owner.inst     = r_cleanup_copy_inst.read();
     5160#if L1_MULTI_CACHE
     5161          entry.owner.cache_id = r_cleanup_copy_cache.read();
     5162#endif
     5163        }
     5164        if (r_read_to_cleanup_is_ll.read())
     5165        {
     5166          r_cleanup_to_tgt_rsp_ll_key = r_read_to_cleanup_ll_key.read();
     5167        }
     5168      }
     5169      else
     5170      {
     5171        entry.count          = r_cleanup_count.read() - 1;
     5172        entry.owner.srcid    = 0;
     5173        entry.owner.inst     = 0;
     5174#if L1_MULTI_CACHE
     5175        entry.owner.cache_id = 0;
     5176#endif
     5177      }
     5178
     5179
     5180      if (r_cleanup_contains_data.read())
     5181      {
     5182        for (size_t word = 0; word < m_words; word ++)
     5183        {
     5184          m_cache_data.write(way, set, word, r_cleanup_data[word].read(), 0xF);
     5185        }
     5186        m_llsc_table.sw(r_cleanup_nline.read());
     5187        //m_llsc_table.sw(r_cleanup_nline.read()*m_words*4);
     5188      }
     5189
    44705190
    44715191      m_cache_directory.write(set, way, entry);
    44725192
    4473       r_cleanup_fsm = CLEANUP_SEND_CLACK;
     5193
     5194      /*RWT*/
     5195      if (inval_request)
     5196      {
     5197        r_cleanup_fsm = CLEANUP_IVT_LOCK_DATA;
     5198      }
     5199      else
     5200      {
     5201        r_cleanup_fsm = CLEANUP_SEND_CLACK;
     5202      }
    44745203
    44755204#if DEBUG_MEMC_CLEANUP
     
    44855214            << " / count = "   << entry.count
    44865215            << " / is_cnt = "  << entry.is_cnt
     5216            << " / match_inval = " << inval_request
    44875217            << std::endl;
    44885218      }
     
    44915221      break;
    44925222    }
    4493 
     5223    /////////////////////
     5224    case CLEANUP_IVT_LOCK_DATA://RWT
     5225    {
     5226    //Search for a matching inval in the UPT (there must be one) and check if there is a pending read.
     5227      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CLEANUP)
     5228      {
     5229        size_t index = 0;
     5230        bool   match_inval;
     5231
     5232        match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
     5233        assert (match_inval && "VCI MEM CACHE ERROR: In CLEANUP_IVT_LOCK_DATA, NO CORRESPONDING INVAL");
     5234        r_cleanup_read_srcid    = m_upt.srcid(index);
     5235        r_cleanup_read_trdid    = m_upt.trdid(index);
     5236        r_cleanup_read_pktid    = 0x0 + m_upt.pktid(index);
     5237        r_cleanup_read_need_rsp = !m_upt.need_rsp(index);
     5238        r_cleanup_index         = index;
     5239
     5240        r_cleanup_fsm = CLEANUP_IVT_CLEAR_DATA;
     5241      }
     5242#if DEBUG_MC_CLEANUP
     5243      if (m_debug)
     5244      {
     5245        std::cout
     5246            << " <MEMC " << name()
     5247            << " CLEANUP_IVT_LOCK_DATA> fetch pending inval"
     5248            << std::endl;
     5249      }
     5250#endif
     5251    break;
     5252    }
     5253
     5254    //////////////////////////
     5255    case CLEANUP_IVT_CLEAR_DATA://RWT
     5256    {
     5257      m_upt.clear(r_cleanup_index.read());
     5258      assert ((r_cleanup_read_need_rsp.read() == (r_read_to_cleanup_req.read() && (r_cleanup_nline.read() == r_read_to_cleanup_nline.read()))) && "condition pending read");
     5259      if (r_cleanup_read_need_rsp.read())
     5260      {
     5261        r_cleanup_fsm = CLEANUP_READ_RSP;
     5262      }
     5263      else
     5264      {
     5265        r_cleanup_fsm = CLEANUP_SEND_CLACK;
     5266      }
     5267#if DEBUG_MC_CLEANUP
     5268      if (m_debug)
     5269      {
     5270        std::cout
     5271            << " <MEMC " << name()
     5272            << " CLEANUP_IVT_CLEAR_DATA> clear UPT entry"
     5273            << std::endl;
     5274      }
     5275#endif
     5276    break;
     5277    }
     5278
     5279    ////////////////////////
     5280    case CLEANUP_READ_RSP://RWT
     5281    {
     5282      if(r_cleanup_to_tgt_rsp_req.read()) break;
     5283     
     5284      r_cleanup_to_tgt_rsp_req     = true;
     5285      r_cleanup_to_tgt_rsp_srcid   = r_cleanup_read_srcid.read();
     5286      r_cleanup_to_tgt_rsp_trdid   = r_cleanup_read_trdid.read();
     5287      r_cleanup_to_tgt_rsp_pktid   = 0x0 + r_cleanup_read_pktid.read();//WT
     5288      r_cleanup_to_tgt_rsp_type    = 0; //Read instruction
     5289      r_cleanup_to_tgt_rsp_length  = r_read_to_cleanup_length.read();
     5290      r_cleanup_to_tgt_rsp_first_word  = r_read_to_cleanup_first_word.read();
     5291      r_read_to_cleanup_req        = false;
     5292      m_cpt_ncc_to_cc_read ++;
     5293      if (r_cleanup_contains_data.read()) //L1 was dirty
     5294      {
     5295        for(size_t i = 0; i<m_words; i++)
     5296        {
     5297          r_cleanup_to_tgt_rsp_data[i] = r_cleanup_data[i].read();
     5298        }
     5299      }
     5300      else //the L2 data are up to date
     5301      {
     5302        for(size_t i = 0; i<m_words; i++)
     5303        {
     5304          r_cleanup_to_tgt_rsp_data[i] = r_cleanup_old_data[i].read();
     5305        }       
     5306      }
     5307
     5308      r_cleanup_fsm                = CLEANUP_SEND_CLACK;
     5309
     5310#if DEBUG_MC_CLEANUP
     5311      if (m_debug)
     5312      {
     5313        std::cout
     5314            << " <MEMC " << name()
     5315            << " CLEANUP_READ_RSP> answer READ"
     5316            << std::endl;
     5317      }
     5318#endif
     5319    break;
     5320    }
    44945321    //////////////////////
    44955322    case CLEANUP_HEAP_REQ:
     
    44975324      // get the lock to the HEAP directory
    44985325      if(r_alloc_heap_fsm.read() != ALLOC_HEAP_CLEANUP) break;
    4499 
     5326 
    45005327      r_cleanup_fsm = CLEANUP_HEAP_LOCK;
    45015328
     
    45095336      }
    45105337#endif
     5338      m_cpt_cleanup_fsm_n_heap_lock++;
    45115339      break;
    45125340    }
     
    45685396          << " / r_cleanup_copy_inst = " << r_cleanup_copy_inst.read() << std::endl
    45695397          << "heap_entry.owner.srcid = " << heap_entry.owner.srcid
    4570           << " / heap_entry.owner.inst = " << heap_entry.owner.inst << std::endl;
     5398          << " / heap_entry.owner.inst = " << heap_entry.owner.inst << std::endl
    45715399/**/
     5400          << "nline = " << r_cleanup_nline << std::endl;
    45725401        exit(0);
    45735402      }
     
    45875416          << " / r_cleanup_copy_inst = " << r_cleanup_copy_inst.read() << std::endl
    45885417          << "heap_entry.owner.srcid = " << heap_entry.owner.srcid
    4589           << " / heap_entry.owner.inst = " << heap_entry.owner.inst << std::endl;
     5418          << " / heap_entry.owner.inst = " << heap_entry.owner.inst << std::endl
    45905419/**/
    4591 
     5420          << "nline = " << r_cleanup_nline << std::endl;
    45925421        exit(0);
    45935422      }
     
    45955424      DirectoryEntry dir_entry;
    45965425      dir_entry.valid          = true;
     5426      dir_entry.cache_coherent = true;
    45975427      dir_entry.is_cnt         = r_cleanup_is_cnt.read();
    45985428      dir_entry.dirty          = r_cleanup_dirty.read();
     
    46525482
    46535483      m_cache_directory.write(set,way,dir_entry);
     5484
    46545485
    46555486#if DEBUG_MEMC_CLEANUP
     
    48545685                             // invalidate transaction matching the cleanup
    48555686    {
     5687      m_cpt_cleanup_fsm_ivt_lock++;
    48565688      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    48575689
     
    48605692
    48615693      match_inval = m_ivt.search_inval(r_cleanup_nline.read(), index);
    4862 
    48635694      if ( not match_inval )     // no pending inval
    48645695      {
     
    48745705          << std::endl;
    48755706#endif
    4876           break;
     5707        m_cpt_cleanup_fsm_n_upt_lock++;
     5708        break;
    48775709      }
    48785710
     
    49145746      m_ivt.decrement(r_cleanup_index.read(), count);
    49155747
     5748
    49165749      if(count == 0)   // multi inval transaction completed
    49175750      {
     
    49205753      else             // multi inval transaction not completed
    49215754      {
    4922         r_cleanup_fsm = CLEANUP_SEND_CLACK ;
     5755        if (r_cleanup_ncc.read()) //need to put data to the XRAM
     5756        {
     5757          r_cleanup_fsm = CLEANUP_IXR_REQ;
     5758        }
     5759        else
     5760        {
     5761          r_cleanup_fsm = CLEANUP_SEND_CLACK;
     5762        }
    49235763      }
    49245764
     
    49505790      if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
    49515791      else if ( r_cleanup_need_ack.read() ) r_cleanup_fsm = CLEANUP_CONFIG_ACK;
     5792      else if ( r_cleanup_ncc.read()      ) r_cleanup_fsm = CLEANUP_IXR_REQ;
    49525793      else                                  r_cleanup_fsm = CLEANUP_SEND_CLACK;
    49535794
     
    49715812      r_cleanup_to_tgt_rsp_trdid   = r_cleanup_write_trdid.read();
    49725813      r_cleanup_to_tgt_rsp_pktid   = r_cleanup_write_pktid.read();
    4973 
    4974       r_cleanup_fsm                = CLEANUP_SEND_CLACK;
     5814      r_cleanup_to_tgt_rsp_type    = true;
     5815
     5816      if (r_cleanup_ncc.read())
     5817      {
     5818        r_cleanup_fsm = CLEANUP_IXR_REQ;//need to put data to the XRAM
     5819      }
     5820      else
     5821      {
     5822        r_cleanup_fsm = CLEANUP_SEND_CLACK;
     5823      }
    49755824
    49765825#if DEBUG_MEMC_CLEANUP
     
    50005849      break;
    50015850    }
     5851
     5852    /////////////////////////
     5853    case CLEANUP_IXR_REQ:
     5854    {
     5855   
     5856      //Send a request to the ixr to write the data in the XRAM using the prereserved TRT entry
     5857      if (r_alloc_trt_fsm.read() == ALLOC_TRT_CLEANUP)
     5858      {
     5859        if(!r_cleanup_to_ixr_cmd_req.read())
     5860        {
     5861          size_t index = 0;
     5862          bool   hit   = m_trt.hit_write(r_cleanup_nline.read(), &index);
     5863
     5864          assert (hit and "CLEANUP_IXR_REQ found no matching entry in TRT");
     5865
     5866            r_cleanup_to_ixr_cmd_req     = true;
     5867
     5868            for(size_t i = 0; i < m_words; i++){
     5869              r_cleanup_to_ixr_cmd_data[i]   = r_cleanup_data[i];
     5870            }
     5871
     5872            r_cleanup_to_ixr_cmd_srcid   = r_cleanup_srcid.read();
     5873            r_cleanup_to_ixr_cmd_trdid   = index;
     5874            r_cleanup_to_ixr_cmd_pktid   = r_cleanup_pktid.read();
     5875            r_cleanup_to_ixr_cmd_nline   = r_cleanup_nline.read();
     5876            r_cleanup_to_ixr_cmd_ncc_l1_dirty = r_cleanup_contains_data.read();
     5877            r_cleanup_fsm = CLEANUP_SEND_CLACK;
     5878#if DEBUG_MEMC_CLEANUP
     5879      if(m_debug)
     5880      {
     5881        std::cout
     5882            << "  <MEMC " << name()
     5883            << " CLEANUP_IXR_REQ>"
     5884            << " request send to IXR_CMD"
     5885            << std::endl;
     5886      }
     5887#endif
     5888        }
     5889        else
     5890        {
     5891            r_cleanup_fsm = CLEANUP_WAIT;
     5892#if DEBUG_MEMC_CLEANUP
     5893      if(m_debug)
     5894      {
     5895        std::cout
     5896            << "  <MEMC " << name()
     5897            << " CLEANUP_IXR_REQ>"
     5898            << " waiting completion of previous request"
     5899            << std::endl;
     5900      }
     5901#endif
     5902        }
     5903      }
     5904      break;
     5905    }
     5906
     5907    /////////////////////
     5908    case CLEANUP_WAIT :
     5909    {
     5910      r_cleanup_fsm = CLEANUP_IXR_REQ;
     5911      break;
     5912    }
     5913
    50025914    ////////////////////////
    50035915    case CLEANUP_SEND_CLACK:  // acknowledgement to a cleanup command
     
    51026014      {
    51036015        r_cas_fsm = CAS_DIR_LOCK;
     6016        m_cpt_cas_fsm_n_dir_lock++;
    51046017      }
    51056018
     
    51126025      }
    51136026#endif
     6027
     6028      m_cpt_cas_fsm_dir_lock++;
     6029
    51146030      break;
    51156031    }
     
    51246040
    51256041        r_cas_is_cnt     = entry.is_cnt;
     6042        r_cas_coherent   = entry.cache_coherent;
    51266043        r_cas_dirty      = entry.dirty;
    51276044        r_cas_tag        = entry.tag;
     
    51716088      DirectoryEntry entry;
    51726089      entry.valid          = true;
     6090      entry.cache_coherent = r_cas_coherent.read();
    51736091      entry.is_cnt         = r_cas_is_cnt.read();
    51746092      entry.dirty          = true;
     
    52386156    {
    52396157      // The CAS is a success => sw access to the llsc_global_table
    5240       m_llsc_table.sw(m_cmd_cas_addr_fifo.read());
     6158      // BUG LLSC
     6159      addr_t      nline      = m_nline[(addr_t)(m_cmd_cas_addr_fifo.read())];
     6160      m_llsc_table.sw(nline);
     6161      //m_llsc_table.sw(m_cmd_cas_addr_fifo.read());
     6162          /**//*std::cout << "MEMCACHE : from proc " << m_cmd_cas_srcid_fifo.read()
     6163                        << " | @ " << std::hex << m_cmd_cas_addr_fifo.read()
     6164                        << " | WRITE (cas triggered)" << std::endl;*/
    52416165
    52426166      // test coherence request
     
    53556279          << " / count = " << nb_copies << std::endl;
    53566280#endif
    5357       }
     6281        m_cpt_cas_fsm_n_upt_lock++;
     6282      }
     6283
     6284      m_cpt_cas_fsm_upt_lock++;
     6285
    53586286      break;
    53596287    }
     
    53866314#endif
    53876315        r_cas_fsm = CAS_UPT_REQ;
    5388       }
     6316        m_cpt_cas_fsm_n_heap_lock++;
     6317      }
     6318
     6319      m_cpt_cas_fsm_heap_lock++;
     6320
    53896321      break;
    53906322    }
     
    55266458          r_cas_fsm = CAS_WAIT;
    55276459        }
    5528       }
     6460        m_cpt_cas_fsm_n_trt_lock++;
     6461      }
     6462
     6463      m_cpt_cas_fsm_trt_lock++;
     6464
    55296465      break;
    55306466    }
     
    55916527          r_cas_fsm = CAS_WAIT;
    55926528        }
    5593       }
     6529        m_cpt_cas_fsm_n_upt_lock++;
     6530      }
     6531
     6532      m_cpt_cas_fsm_upt_lock++;
     6533
    55946534      break;
    55956535    }
     
    57696709          r_cas_fsm       = CAS_MISS_TRT_SET;
    57706710        }
    5771       }
     6711        m_cpt_cas_fsm_n_trt_lock++;
     6712      }
     6713
     6714      m_cpt_cas_fsm_trt_lock++;
     6715
    57726716      break;
    57736717    }
     
    58976841          break;
    58986842        }
     6843
     6844        if(r_read_to_cc_send_req.read())
     6845        {
     6846          r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_HEADER;
     6847          break;
     6848        }
     6849
     6850        if(r_write_to_cc_send_req.read())
     6851        {
     6852          r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     6853          break;
     6854        }
     6855
     6856
    58996857        // WRITE
     6858        if(r_read_to_cc_send_req.read())
     6859        {
     6860          r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_HEADER;
     6861          break;
     6862        }
     6863
     6864        if(r_write_to_cc_send_req.read())
     6865        {
     6866          r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     6867          break;
     6868        }
    59006869        if(m_write_to_cc_send_inst_fifo.rok() or
    59016870            r_write_to_cc_send_multi_req.read())
     
    59716940        }
    59726941        // WRITE
     6942        if(r_read_to_cc_send_req.read())
     6943        {
     6944          r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_HEADER;
     6945          break;
     6946        }
     6947
     6948        if(r_write_to_cc_send_req.read())
     6949        {
     6950          r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     6951          break;
     6952        }
    59736953        if(m_write_to_cc_send_inst_fifo.rok() or
    59746954            r_write_to_cc_send_multi_req.read())
     
    60036983          break;
    60046984        }
     6985
     6986        if(r_read_to_cc_send_req.read())
     6987        {
     6988          r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_HEADER;
     6989          break;
     6990        }
     6991
     6992        if(r_write_to_cc_send_req.read())
     6993        {
     6994          r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     6995          break;
     6996        }
     6997
     6998
    60056999        // WRITE
     7000        if(r_read_to_cc_send_req.read())
     7001        {
     7002          r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_HEADER;
     7003          break;
     7004        }
     7005
     7006        if(r_write_to_cc_send_req.read())
     7007        {
     7008          r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     7009          break;
     7010        }
    60067011        if(m_write_to_cc_send_inst_fifo.rok() or
    60077012            r_write_to_cc_send_multi_req.read())
     
    60507055      case CC_SEND_CAS_IDLE:   // CLEANUP FSM has highest priority
    60517056      {
     7057
     7058        if(r_read_to_cc_send_req.read())
     7059        {
     7060          r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_HEADER;
     7061          break;
     7062        }
     7063
     7064        if(r_write_to_cc_send_req.read())
     7065        {
     7066          r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     7067          break;
     7068        }
     7069
     7070
    60527071        if(m_write_to_cc_send_inst_fifo.rok() or
    60537072            r_write_to_cc_send_multi_req.read())
     
    62087227        break;
    62097228      }
     7229
     7230    case CC_SEND_READ_NCC_INVAL_HEADER:
     7231      {
     7232        if(not p_dspin_m2p.read) break;
     7233
     7234        r_cc_send_fsm = CC_SEND_READ_NCC_INVAL_NLINE;
     7235        break;
     7236      }
     7237
     7238    case CC_SEND_READ_NCC_INVAL_NLINE:
     7239      {
     7240        if(not p_dspin_m2p.read) break;
     7241
     7242        r_read_to_cc_send_req = false;
     7243        r_cc_send_fsm = CC_SEND_WRITE_IDLE;
     7244
     7245#if DEBUG_MEMC_CC_SEND
     7246        if(m_debug)
     7247        {
     7248          std::cout
     7249            << "  <MEMC " << name()
     7250            << " CC_SEND_READ_NCC_INVAL_HEADER> Inval for line "
     7251            << r_read_to_cc_send_nline.read()
     7252            << std::endl;
     7253        }
     7254#endif
     7255        break;
     7256      }
     7257
     7258
     7259    case CC_SEND_WRITE_NCC_INVAL_HEADER:
     7260      {
     7261        if(not p_dspin_m2p.read) break;
     7262
     7263        r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_NLINE;
     7264        break;
     7265      }
     7266
     7267    case CC_SEND_WRITE_NCC_INVAL_NLINE:
     7268      {
     7269        if(not p_dspin_m2p.read) break;
     7270
     7271        r_write_to_cc_send_req = false;
     7272        r_cc_send_fsm = CC_SEND_WRITE_IDLE;
     7273
     7274#if DEBUG_MEMC_CC_SEND
     7275        if(m_debug)
     7276        {
     7277          std::cout
     7278            << "  <MEMC " << name()
     7279            << " CC_SEND_WRITE_NCC_INVAL_HEADER> Inval for line "
     7280            << r_write_to_cc_send_nline.read()
     7281            << std::endl;
     7282        }
     7283#endif
     7284        break;
     7285      }
     7286
     7287
    62107288      //////////////////////////////////
    62117289      case CC_SEND_WRITE_BRDCAST_HEADER:   // send first flit broadcast-inval (from WRITE FSM)
     
    64177495          break;
    64187496
    6419         assert(not p_dspin_p2m.eop.read() and
    6420             "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    6421             "CLEANUP command must have two flits");
    6422 
    64237497        cc_receive_to_cleanup_fifo_put = true;
    6424         r_cc_receive_fsm               = CC_RECEIVE_CLEANUP_EOP;
     7498        if(p_dspin_p2m.eop.read())
     7499          r_cc_receive_fsm               = CC_RECEIVE_IDLE;
    64257500
    64267501        break;