Ignore:
Timestamp:
Jul 26, 2013, 5:03:12 PM (11 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:
2 added
2 edited
2 copied

Legend:

Unmodified
Added
Removed

  • 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        }
Note: See TracChangeset for help on using the changeset viewer.