Changeset 827


Ignore:
Timestamp:
Oct 1, 2014, 5:44:55 PM (8 years ago)
Author:
devigne
Message:

RWT Commit : vci_cc_vcache_wrapper cosmetic

Location:
branches/RWT/modules/vci_cc_vcache_wrapper/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r824 r827  
    3535#include <inttypes.h>
    3636#include <systemc>
    37 
    3837#include "caba_base_module.h"
    3938#include "multi_write_buffer.h"
     
    307306    soclib::common::AddressDecodingTable<uint64_t, bool> m_cacheability_table;
    308307
    309     const size_t                        m_srcid;
    310     const size_t                        m_cc_global_id;
    311     const size_t                        m_nline_width;
    312     const size_t                        m_itlb_ways;
    313     const size_t                        m_itlb_sets;
    314     const size_t                        m_dtlb_ways;
    315     const size_t                        m_dtlb_sets;
    316     const size_t                        m_icache_ways;
    317     const size_t                        m_icache_sets;
    318     const paddr_t                       m_icache_yzmask;
    319     const size_t                        m_icache_words;
    320     const size_t                        m_dcache_ways;
    321     const size_t                        m_dcache_sets;
    322     const paddr_t                       m_dcache_yzmask;
    323     const size_t                        m_dcache_words;
    324     const size_t                        m_x_width;
    325     const size_t                        m_y_width;
    326     const size_t                        m_proc_id;
    327     const uint32_t                      m_max_frozen_cycles;
    328     const size_t                        m_paddr_nbits;
    329     uint32_t                            m_debug_start_cycle;
    330     bool                                m_debug_ok;
    331 
    332     uint32_t                            m_dcache_paddr_ext_reset;
    333     uint32_t                            m_icache_paddr_ext_reset;
     308    const size_t   m_srcid;
     309    const size_t   m_cc_global_id;
     310    const size_t   m_nline_width;
     311    const size_t   m_itlb_ways;
     312    const size_t   m_itlb_sets;
     313    const size_t   m_dtlb_ways;
     314    const size_t   m_dtlb_sets;
     315    const size_t   m_icache_ways;
     316    const size_t   m_icache_sets;
     317    const paddr_t  m_icache_yzmask;
     318    const size_t   m_icache_words;
     319    const size_t   m_dcache_ways;
     320    const size_t   m_dcache_sets;
     321    const paddr_t  m_dcache_yzmask;
     322    const size_t   m_dcache_words;
     323    const size_t   m_x_width;
     324    const size_t   m_y_width;
     325    const size_t   m_proc_id;
     326    const uint32_t m_max_frozen_cycles;
     327    const size_t   m_paddr_nbits;
     328    uint32_t       m_debug_start_cycle;
     329    bool           m_debug_ok;
     330
     331    uint32_t       m_dcache_paddr_ext_reset;
     332    uint32_t       m_icache_paddr_ext_reset;
    334333
    335334    ////////////////////////////////////////
     
    344343    // debug variables
    345344    /////////////////////////////////////////////
    346     bool                                m_debug_previous_i_hit;
    347     bool                                m_debug_previous_d_hit;
    348     bool                                m_debug_activated;
     345    bool m_debug_previous_i_hit;
     346    bool m_debug_previous_d_hit;
     347    bool m_debug_activated;
    349348
    350349    ///////////////////////////////
    351350    // Software visible REGISTERS
    352351    ///////////////////////////////
    353     sc_signal<uint32_t>     r_mmu_ptpr;      // page table pointer register
    354     sc_signal<uint32_t>     r_mmu_mode;      // mmu mode register
    355     sc_signal<uint32_t>     r_mmu_word_lo;  // mmu misc data low
    356     sc_signal<uint32_t>     r_mmu_word_hi;  // mmu misc data hight
    357     sc_signal<uint32_t>     r_mmu_ibvar;     // mmu bad instruction address
    358     sc_signal<uint32_t>     r_mmu_dbvar;     // mmu bad data address
    359     sc_signal<uint32_t>     r_mmu_ietr;      // mmu instruction error type
    360     sc_signal<uint32_t>     r_mmu_detr;      // mmu data error type
    361     uint32_t                r_mmu_params;    // read-only
    362     uint32_t                r_mmu_release;  // read_only
     352    sc_signal<uint32_t> r_mmu_ptpr;    // page table pointer register
     353    sc_signal<uint32_t> r_mmu_mode;    // mmu mode register
     354    sc_signal<uint32_t> r_mmu_word_lo; // mmu misc data low
     355    sc_signal<uint32_t> r_mmu_word_hi; // mmu misc data hight
     356    sc_signal<uint32_t> r_mmu_ibvar;   // mmu bad instruction address
     357    sc_signal<uint32_t> r_mmu_dbvar;   // mmu bad data address
     358    sc_signal<uint32_t> r_mmu_ietr;    // mmu instruction error type
     359    sc_signal<uint32_t> r_mmu_detr;    // mmu data error type
     360    uint32_t            r_mmu_params;  // read-only
     361    uint32_t            r_mmu_release; // read_only
    363362
    364363
     
    366365    // ICACHE FSM REGISTERS
    367366    //////////////////////////////
    368     sc_signal<int>          r_icache_fsm;               // state register
    369     sc_signal<int>          r_icache_fsm_save;          // return state for coherence op
    370     sc_signal<paddr_t>      r_icache_vci_paddr;         // physical address
    371     sc_signal<uint32_t>     r_icache_vaddr_save;        // virtual address from processor
     367    sc_signal<int>      r_icache_fsm;        // state register
     368    sc_signal<int>      r_icache_fsm_save;   // return state for coherence op
     369    sc_signal<paddr_t>  r_icache_vci_paddr;  // physical address
     370    sc_signal<uint32_t> r_icache_vaddr_save; // virtual address from processor
    372371
    373372    // icache miss handling
    374     sc_signal<size_t>       r_icache_miss_way;          // selected way for cache update
    375     sc_signal<size_t>       r_icache_miss_set;          // selected set for cache update
    376     sc_signal<size_t>       r_icache_miss_word;         // word index ( cache update)
    377     sc_signal<bool>         r_icache_miss_inval;        // coherence request matching a miss
    378     sc_signal<bool>         r_icache_miss_clack;        // waiting for a cleanup acknowledge
     373    sc_signal<size_t>   r_icache_miss_way;   // selected way for cache update
     374    sc_signal<size_t>   r_icache_miss_set;   // selected set for cache update
     375    sc_signal<size_t>   r_icache_miss_word;  // word index ( cache update)
     376    sc_signal<bool>     r_icache_miss_inval; // coherence request matching a miss
     377    sc_signal<bool>     r_icache_miss_clack; // waiting for a cleanup acknowledge
    379378
    380379    // coherence request handling
    381     sc_signal<size_t>       r_icache_cc_way;            // selected way for cc update/inval
    382     sc_signal<size_t>       r_icache_cc_set;            // selected set for cc update/inval
    383     sc_signal<size_t>       r_icache_cc_word;           // word counter for cc update
    384     sc_signal<bool>         r_icache_cc_need_write;    // activate the cache for writing
     380    sc_signal<size_t>   r_icache_cc_way;        // selected way for cc update/inval
     381    sc_signal<size_t>   r_icache_cc_set;        // selected set for cc update/inval
     382    sc_signal<size_t>   r_icache_cc_word;       // word counter for cc update
     383    sc_signal<bool>     r_icache_cc_need_write; // activate the cache for writing
    385384
    386385    // coherence clack handling
    387     sc_signal<bool>         r_icache_clack_req;        // clack request
    388     sc_signal<size_t>       r_icache_clack_way;        // clack way
    389     sc_signal<size_t>       r_icache_clack_set;        // clack set
     386    sc_signal<bool>     r_icache_clack_req; // clack request
     387    sc_signal<size_t>   r_icache_clack_way; // clack way
     388    sc_signal<size_t>   r_icache_clack_set; // clack set
    390389
    391390    // icache flush handling
    392     sc_signal<size_t>       r_icache_flush_count;      // slot counter used for cache flush
     391    sc_signal<size_t>   r_icache_flush_count; // slot counter used for cache flush
    393392
    394393    // communication between ICACHE FSM and VCI_CMD FSM
    395     sc_signal<bool>         r_icache_miss_req;          // cached read miss
    396     sc_signal<bool>         r_icache_unc_req;            // uncached read miss
     394    sc_signal<bool>     r_icache_miss_req; // cached read miss
     395    sc_signal<bool>     r_icache_unc_req;  // uncached read miss
    397396
    398397    // communication between ICACHE FSM and DCACHE FSM
    399     sc_signal<bool>         r_icache_tlb_miss_req;       // (set icache/reset dcache)
    400     sc_signal<bool>         r_icache_tlb_rsp_error;      // tlb miss response error
     398    sc_signal<bool>     r_icache_tlb_miss_req;  // (set icache/reset dcache)
     399    sc_signal<bool>     r_icache_tlb_rsp_error; // tlb miss response error
    401400
    402401    // Flip-Flop in ICACHE FSM for saving the cleanup victim request
    403     sc_signal<bool>         r_icache_cleanup_victim_req;
    404     sc_signal<paddr_t>      r_icache_cleanup_victim_nline;
     402    sc_signal<bool>     r_icache_cleanup_victim_req;
     403    sc_signal<paddr_t>  r_icache_cleanup_victim_nline;
    405404
    406405    // communication between ICACHE FSM and CC_SEND FSM
    407     sc_signal<bool>         r_icache_cc_send_req;           // ICACHE cc_send request
    408     sc_signal<int>          r_icache_cc_send_type;          // ICACHE cc_send request type
    409     sc_signal<paddr_t>      r_icache_cc_send_nline;         // ICACHE cc_send nline
    410     sc_signal<size_t>       r_icache_cc_send_way;           // ICACHE cc_send way
    411     sc_signal<size_t>       r_icache_cc_send_updt_tab_idx; // ICACHE cc_send update table index
     406    sc_signal<bool>     r_icache_cc_send_req;          // ICACHE cc_send request
     407    sc_signal<int>      r_icache_cc_send_type;         // ICACHE cc_send request type
     408    sc_signal<paddr_t>  r_icache_cc_send_nline;        // ICACHE cc_send nline
     409    sc_signal<size_t>   r_icache_cc_send_way;          // ICACHE cc_send way
     410    sc_signal<size_t>   r_icache_cc_send_updt_tab_idx; // ICACHE cc_send update table index
    412411
    413412    // Physical address extension for data access
    414     sc_signal<uint32_t>     r_icache_paddr_ext;            // CP2 register (if vci_address > 32)
     413    sc_signal<uint32_t> r_icache_paddr_ext; // CP2 register (if vci_address > 32)
    415414
    416415    ///////////////////////////////
    417416    // DCACHE FSM REGISTERS
    418417    ///////////////////////////////
    419     sc_signal<int>          r_dcache_fsm;               // state register
    420     sc_signal<int>          r_dcache_fsm_cc_save;       // return state for coherence op
    421     sc_signal<int>          r_dcache_fsm_scan_save;     // return state for tlb scan op
     418    sc_signal<int>      r_dcache_fsm;             // state register
     419    sc_signal<int>      r_dcache_fsm_cc_save;     // return state for coherence op
     420    sc_signal<int>      r_dcache_fsm_scan_save;   // return state for tlb scan op
    422421    // registers written in P0 stage (used in P1 stage)
    423     sc_signal<bool>         r_dcache_wbuf_req;          // WBUF must be written in P1 stage
    424     sc_signal<bool>         r_dcache_updt_req;          // DCACHE must be updated in P1 stage
    425     sc_signal<uint32_t>     r_dcache_save_vaddr;        // virtual address (from proc)
    426     sc_signal<uint32_t>     r_dcache_save_wdata;        // write data (from proc)
    427     sc_signal<uint32_t>     r_dcache_save_be;           // byte enable (from proc)
    428     sc_signal<paddr_t>      r_dcache_save_paddr;        // physical address
    429     sc_signal<size_t>       r_dcache_save_cache_way;    // selected way (from dcache)
    430     sc_signal<size_t>       r_dcache_save_cache_set;    // selected set (from dcache)
    431     sc_signal<size_t>       r_dcache_save_cache_word;  // selected word (from dcache)
     422    sc_signal<bool>     r_dcache_wbuf_req;        // WBUF must be written in P1 stage
     423    sc_signal<bool>     r_dcache_updt_req;        // DCACHE must be updated in P1 stage
     424    sc_signal<uint32_t> r_dcache_save_vaddr;      // virtual address (from proc)
     425    sc_signal<uint32_t> r_dcache_save_wdata;      // write data (from proc)
     426    sc_signal<uint32_t> r_dcache_save_be;         // byte enable (from proc)
     427    sc_signal<paddr_t>  r_dcache_save_paddr;      // physical address
     428    sc_signal<size_t>   r_dcache_save_cache_way;  // selected way (from dcache)
     429    sc_signal<size_t>   r_dcache_save_cache_set;  // selected set (from dcache)
     430    sc_signal<size_t>   r_dcache_save_cache_word; // selected word (from dcache)
    432431    // registers used by the Dirty bit sub-fsm
    433     sc_signal<paddr_t>      r_dcache_dirty_paddr;      // PTE physical address
    434     sc_signal<size_t>       r_dcache_dirty_way;         // way to invalidate in dcache
    435     sc_signal<size_t>       r_dcache_dirty_set;         // set to invalidate in dcache
     432    sc_signal<paddr_t>  r_dcache_dirty_paddr; // PTE physical address
     433    sc_signal<size_t>   r_dcache_dirty_way;   // way to invalidate in dcache
     434    sc_signal<size_t>   r_dcache_dirty_set;   // set to invalidate in dcache
    436435
    437436    // communication between DCACHE FSM and VCI_CMD FSM
    438     sc_signal<paddr_t>      r_dcache_vci_paddr;         // physical address for VCI command
    439     sc_signal<uint32_t>     r_dcache_vci_wdata;         // write unc data for VCI command
    440     sc_signal<bool>         r_dcache_vci_miss_req;      // read miss request
    441     sc_signal<bool>         r_dcache_vci_unc_req;       // uncacheable request (read/write)
    442     sc_signal<uint32_t>     r_dcache_vci_unc_be;        // uncacheable byte enable
    443     sc_signal<uint32_t>     r_dcache_vci_unc_write;    // uncacheable data write request
    444     sc_signal<bool>         r_dcache_vci_cas_req;       // atomic write request CAS
    445     sc_signal<uint32_t>     r_dcache_vci_cas_old;       // previous data value for a CAS
    446     sc_signal<uint32_t>     r_dcache_vci_cas_new;       // new data value for a CAS
    447     sc_signal<bool>         r_dcache_vci_ll_req;        // atomic read request LL
    448     sc_signal<bool>         r_dcache_vci_sc_req;        // atomic write request SC
    449     sc_signal<uint32_t>     r_dcache_vci_sc_data;       // SC data (command)
     437    sc_signal<paddr_t>  r_dcache_vci_paddr;     // physical address for VCI command
     438    sc_signal<uint32_t> r_dcache_vci_wdata;     // write unc data for VCI command
     439    sc_signal<bool>     r_dcache_vci_miss_req;  // read miss request
     440    sc_signal<bool>     r_dcache_vci_unc_req;   // uncacheable request (read/write)
     441    sc_signal<uint32_t> r_dcache_vci_unc_be;    // uncacheable byte enable
     442    sc_signal<uint32_t> r_dcache_vci_unc_write; // uncacheable data write request
     443    sc_signal<bool>     r_dcache_vci_cas_req;   // atomic write request CAS
     444    sc_signal<uint32_t> r_dcache_vci_cas_old;   // previous data value for a CAS
     445    sc_signal<uint32_t> r_dcache_vci_cas_new;   // new data value for a CAS
     446    sc_signal<bool>     r_dcache_vci_ll_req;    // atomic read request LL
     447    sc_signal<bool>     r_dcache_vci_sc_req;    // atomic write request SC
     448    sc_signal<uint32_t> r_dcache_vci_sc_data;   // SC data (command)
    450449
    451450    //RWT: local cas
    452     sc_signal<bool>         r_cas_islocal;
    453     sc_signal<size_t>       r_cas_local_way;
    454     sc_signal<size_t>       r_cas_local_set;
    455     sc_signal<size_t>       r_cas_local_word;
     451    sc_signal<bool>     r_cas_islocal;
     452    sc_signal<size_t>   r_cas_local_way;
     453    sc_signal<size_t>   r_cas_local_set;
     454    sc_signal<size_t>   r_cas_local_word;
    456455
    457456    // register used for XTN inval
    458     sc_signal<size_t>       r_dcache_xtn_way;          // selected way (from dcache)
    459     sc_signal<size_t>       r_dcache_xtn_set;          // selected set (from dcache)
     457    sc_signal<size_t>   r_dcache_xtn_way; // selected way (from dcache)
     458    sc_signal<size_t>   r_dcache_xtn_set; // selected set (from dcache)
    460459
    461460    // handling dcache miss
    462     sc_signal<int>          r_dcache_miss_type;         // depending on the requester
    463     sc_signal<size_t>       r_dcache_miss_word;         // word index for cache update
    464     sc_signal<size_t>       r_dcache_miss_way;          // selected way for cache update
    465     sc_signal<size_t>       r_dcache_miss_set;          // selected set for cache update
    466     sc_signal<bool>         r_dcache_miss_inval;        // coherence request matching a miss
    467     sc_signal<bool>         r_dcache_miss_clack;        // waiting for a cleanup acknowledge
     461    sc_signal<int>      r_dcache_miss_type;  // depending on the requester
     462    sc_signal<size_t>   r_dcache_miss_word;  // word index for cache update
     463    sc_signal<size_t>   r_dcache_miss_way;   // selected way for cache update
     464    sc_signal<size_t>   r_dcache_miss_set;   // selected set for cache update
     465    sc_signal<bool>     r_dcache_miss_inval; // coherence request matching a miss
     466    sc_signal<bool>     r_dcache_miss_clack; // waiting for a cleanup acknowledge
    468467
    469468    // handling coherence requests
    470     sc_signal<size_t>       r_dcache_cc_way;            // selected way for cc update/inval
    471     sc_signal<size_t>       r_dcache_cc_set;            // selected set for cc update/inval
    472     sc_signal<int>          r_dcache_cc_state;          // state of selected cache slot
    473     sc_signal<size_t>       r_dcache_cc_word;           // word counter for cc update
    474     sc_signal<bool>         r_dcache_cc_need_write;    // activate the cache for writing
    475     sc_signal<paddr_t>      r_dcache_cc_inval_addr;    // address for a cleanup transaction
    476     sc_signal<uint32_t>     r_dcache_cc_inval_data_cpt;
     469    sc_signal<size_t>   r_dcache_cc_way;        // selected way for cc update/inval
     470    sc_signal<size_t>   r_dcache_cc_set;        // selected set for cc update/inval
     471    sc_signal<int>      r_dcache_cc_state;      // state of selected cache slot
     472    sc_signal<size_t>   r_dcache_cc_word;       // word counter for cc update
     473    sc_signal<bool>     r_dcache_cc_need_write; // activate the cache for writing
     474    sc_signal<paddr_t>  r_dcache_cc_inval_addr; // address for a cleanup transaction
     475    sc_signal<uint32_t> r_dcache_cc_inval_data_cpt;
    477476
    478477    // coherence clack handling
    479     sc_signal<bool>         r_dcache_clack_req;        // clack request
    480     sc_signal<size_t>       r_dcache_clack_way;        // clack way
    481     sc_signal<size_t>       r_dcache_clack_set;        // clack set
     478    sc_signal<bool>     r_dcache_clack_req; // clack request
     479    sc_signal<size_t>   r_dcache_clack_way; // clack way
     480    sc_signal<size_t>   r_dcache_clack_set; // clack set
    482481
    483482    // dcache flush handling
    484     sc_signal<size_t>       r_dcache_flush_count;      // slot counter used for cache flush
     483    sc_signal<size_t>   r_dcache_flush_count; // slot counter used for cache flush
    485484
    486485    // ll response handling
    487     sc_signal<size_t>       r_dcache_ll_rsp_count;      // flit counter used for ll rsp
     486    sc_signal<size_t>   r_dcache_ll_rsp_count; // flit counter used for ll rsp
    488487
    489488    // used by the TLB miss sub-fsm
    490     sc_signal<uint32_t>     r_dcache_tlb_vaddr;         // virtual address for a tlb miss
    491     sc_signal<bool>         r_dcache_tlb_ins;           // target tlb (itlb if true)
    492     sc_signal<paddr_t>      r_dcache_tlb_paddr;         // physical address of pte
    493     sc_signal<uint32_t>     r_dcache_tlb_pte_flags;     // pte1 or first word of pte2
    494     sc_signal<uint32_t>     r_dcache_tlb_pte_ppn;       // second word of pte2
    495     sc_signal<size_t>       r_dcache_tlb_cache_way;     // selected way in dcache
    496     sc_signal<size_t>       r_dcache_tlb_cache_set;     // selected set in dcache
    497     sc_signal<size_t>       r_dcache_tlb_cache_word;    // selected word in dcache
    498     sc_signal<size_t>       r_dcache_tlb_way;           // selected way in tlb
    499     sc_signal<size_t>       r_dcache_tlb_set;           // selected set in tlb
     489    sc_signal<uint32_t> r_dcache_tlb_vaddr;      // virtual address for a tlb miss
     490    sc_signal<bool>     r_dcache_tlb_ins;        // target tlb (itlb if true)
     491    sc_signal<paddr_t>  r_dcache_tlb_paddr;      // physical address of pte
     492    sc_signal<uint32_t> r_dcache_tlb_pte_flags;  // pte1 or first word of pte2
     493    sc_signal<uint32_t> r_dcache_tlb_pte_ppn;    // second word of pte2
     494    sc_signal<size_t>   r_dcache_tlb_cache_way;  // selected way in dcache
     495    sc_signal<size_t>   r_dcache_tlb_cache_set;  // selected set in dcache
     496    sc_signal<size_t>   r_dcache_tlb_cache_word; // selected word in dcache
     497    sc_signal<size_t>   r_dcache_tlb_way;        // selected way in tlb
     498    sc_signal<size_t>   r_dcache_tlb_set;        // selected set in tlb
    500499
    501500    // ITLB and DTLB invalidation
    502     sc_signal<paddr_t>      r_dcache_tlb_inval_line;    // line index
    503     sc_signal<size_t>       r_dcache_tlb_inval_set;     // tlb set counter
     501    sc_signal<paddr_t>  r_dcache_tlb_inval_line; // line index
     502    sc_signal<size_t>   r_dcache_tlb_inval_set;  // tlb set counter
    504503
    505504    // communication between DCACHE FSM and ICACHE FSM
    506     sc_signal<bool>         r_dcache_xtn_req;           // xtn request (caused by processor)
    507     sc_signal<int>          r_dcache_xtn_opcode;        // xtn request type
     505    sc_signal<bool>     r_dcache_xtn_req;    // xtn request (caused by processor)
     506    sc_signal<int>      r_dcache_xtn_opcode; // xtn request type
    508507
    509508    // Filp-Flop in DCACHE FSM for saving the cleanup victim request
    510     sc_signal<bool>         r_dcache_cleanup_victim_req;
    511     sc_signal<bool>         r_dcache_cleanup_victim_line_ncc;
    512     sc_signal<bool>         r_dcache_cleanup_victim_updt_data;
    513     sc_signal<paddr_t>      r_dcache_cleanup_victim_nline;
     509    sc_signal<bool>     r_dcache_cleanup_victim_req;
     510    sc_signal<bool>     r_dcache_cleanup_victim_line_ncc;
     511    sc_signal<bool>     r_dcache_cleanup_victim_updt_data;
     512    sc_signal<paddr_t>  r_dcache_cleanup_victim_nline;
    514513
    515514    // communication between DCACHE FSM and CC_SEND FSM
    516     sc_signal<bool>         r_dcache_cc_send_req;           // DCACHE cc_send request
    517     sc_signal<int>          r_dcache_cc_send_type;          // DCACHE cc_send request type
    518     sc_signal<paddr_t>      r_dcache_cc_send_nline;         // DCACHE cc_send nline
    519     sc_signal<size_t>       r_dcache_cc_send_way;           // DCACHE cc_send way
    520     sc_signal<size_t>       r_dcache_cc_send_updt_tab_idx; // DCACHE cc_send update table index
     515    sc_signal<bool>     r_dcache_cc_send_req;          // DCACHE cc_send request
     516    sc_signal<int>      r_dcache_cc_send_type;         // DCACHE cc_send request type
     517    sc_signal<paddr_t>  r_dcache_cc_send_nline;        // DCACHE cc_send nline
     518    sc_signal<size_t>   r_dcache_cc_send_way;          // DCACHE cc_send way
     519    sc_signal<size_t>   r_dcache_cc_send_updt_tab_idx; // DCACHE cc_send update table index
    521520
    522521    // special registers for RWT
    523     sc_signal<bool>         r_dcache_cc_cleanup_updt_data;     // Register for cleanup with data (wb updt)
    524     sc_signal<bool>         r_dcache_cc_cleanup_line_ncc;      // Register for cleanup with data (wb updt)
    525     sc_signal<bool>         r_dcache_miss_victim_no_coherence; // Register for victim in no coherence mode
    526     sc_signal<bool>         r_dcache_line_no_coherence;        // Register for line current in no coherence mode
    527     sc_signal<bool>         r_dcache_dirty_save;
    528     sc_signal<uint32_t>     r_cc_send_cpt_word;
    529     sc_signal<uint32_t>     r_dcache_miss_data_cpt;
    530     sc_signal<paddr_t>      r_dcache_miss_data_addr;
    531     sc_signal<uint32_t>     r_dcache_xtn_flush_data_cpt;
    532     sc_signal<paddr_t>      r_dcache_xtn_flush_addr_data;
    533     sc_signal<int>          r_dcache_xtn_state;
    534     sc_signal<paddr_t>      r_dcache_xtn_data_addr;
    535     sc_signal<uint32_t>     r_dcache_xtn_data_cpt;
    536     sc_signal<bool>         r_dcache_read_state;
     522    sc_signal<bool>     r_dcache_cc_cleanup_updt_data; // Register for cleanup with data (wb updt)
     523    sc_signal<bool>     r_dcache_cc_cleanup_line_ncc;  // Register for cleanup with data (wb updt)
     524    sc_signal<bool>     r_dcache_dirty_save;
     525    sc_signal<uint32_t> r_cc_send_cpt_word;
     526    sc_signal<uint32_t> r_dcache_miss_data_cpt;
     527    sc_signal<paddr_t>  r_dcache_miss_data_addr;
     528    sc_signal<uint32_t> r_dcache_xtn_flush_data_cpt;
     529    sc_signal<paddr_t>  r_dcache_xtn_flush_addr_data;
     530    sc_signal<int>      r_dcache_xtn_state;
     531    sc_signal<paddr_t>  r_dcache_xtn_data_addr;
     532    sc_signal<uint32_t> r_dcache_xtn_data_cpt;
     533    sc_signal<bool>     r_dcache_read_state;
    537534
    538535    // dcache directory extension
    539     int                     *r_dcache_content_state; // content state of one cache line
     536    int                 *r_dcache_content_state; // content state of one cache line
    540537    // Stats
    541     int                     *r_dcache_dirty_word;    // use for compute number of words dirty per cleanup_data
    542     bool                    *r_dcache_zombi_ncc;     // use for compute number of blocked write on ncc zombi line
     538    int                 *r_dcache_dirty_word;    // use for compute number of words dirty per cleanup_data
     539    bool                *r_dcache_zombi_ncc;     // use for compute number of blocked write on ncc zombi line
    543540    //////////////////////////////////////////////////////////////////////////////////////
    544541
    545542    ///////////////////////////////////
    546543    // Physical address extension for data access
    547     sc_signal<uint32_t>     r_dcache_paddr_ext;            // CP2 register (if vci_address > 32)
     544    sc_signal<uint32_t> r_dcache_paddr_ext; // CP2 register (if vci_address > 32)
    548545
    549546    ///////////////////////////////////
    550547    // VCI_CMD FSM REGISTERS
    551548    ///////////////////////////////////
    552     sc_signal<int>          r_vci_cmd_fsm;
    553     sc_signal<size_t>       r_vci_cmd_min;                  // used for write bursts
    554     sc_signal<size_t>       r_vci_cmd_max;                  // used for write bursts
    555     sc_signal<size_t>       r_vci_cmd_cpt;                  // used for write bursts
    556     sc_signal<bool>         r_vci_cmd_imiss_prio;          // round-robin between imiss & dmiss
     549    sc_signal<int>      r_vci_cmd_fsm;
     550    sc_signal<size_t>   r_vci_cmd_min;        // used for write bursts
     551    sc_signal<size_t>   r_vci_cmd_max;        // used for write bursts
     552    sc_signal<size_t>   r_vci_cmd_cpt;        // used for write bursts
     553    sc_signal<bool>     r_vci_cmd_imiss_prio; // round-robin between imiss & dmiss
    557554
    558555    ///////////////////////////////////
    559556    // VCI_RSP FSM REGISTERS
    560557    ///////////////////////////////////
    561     sc_signal<int>          r_vci_rsp_fsm;
    562     sc_signal<size_t>       r_vci_rsp_cpt;
    563     sc_signal<bool>         r_vci_rsp_ins_error;
    564     sc_signal<bool>         r_vci_rsp_data_error;
    565     GenericFifo<uint32_t>   r_vci_rsp_fifo_icache;          // response FIFO to ICACHE FSM
    566     GenericFifo<uint32_t>   r_vci_rsp_fifo_dcache;          // response FIFO to DCACHE FSM
     558    sc_signal<int>        r_vci_rsp_fsm;
     559    sc_signal<size_t>     r_vci_rsp_cpt;
     560    sc_signal<bool>       r_vci_rsp_ins_error;
     561    sc_signal<bool>       r_vci_rsp_data_error;
     562    GenericFifo<uint32_t> r_vci_rsp_fifo_icache; // response FIFO to ICACHE FSM
     563    GenericFifo<uint32_t> r_vci_rsp_fifo_dcache; // response FIFO to DCACHE FSM
    567564
    568565
    569566    //RWT
    570     GenericFifo<bool>       r_vci_rsp_fifo_rpktid;
    571     GenericFifo<uint32_t>   r_cc_send_data_fifo;
     567    GenericFifo<bool>     r_vci_rsp_fifo_rpktid;
     568    GenericFifo<uint32_t> r_cc_send_data_fifo;
    572569
    573570    ///////////////////////////////////
    574571    //  CC_SEND FSM REGISTER
    575572    ///////////////////////////////////
    576     sc_signal<int>          r_cc_send_fsm;                  // state register
    577     sc_signal<bool>         r_cc_send_last_client;          // 0 dcache / 1 icache
     573    sc_signal<int>        r_cc_send_fsm;         // state register
     574    sc_signal<bool>       r_cc_send_last_client; // 0 dcache / 1 icache
    578575
    579576    ///////////////////////////////////
    580577    //  CC_RECEIVE FSM REGISTER
    581578    ///////////////////////////////////
    582     sc_signal<int>          r_cc_receive_fsm;               // state register
    583     sc_signal<bool>         r_cc_receive_data_ins;          // request to : 0 dcache / 1 icache
     579    sc_signal<int>        r_cc_receive_fsm;      // state register
     580    sc_signal<bool>       r_cc_receive_data_ins; // request to : 0 dcache / 1 icache
    584581
    585582    // communication between CC_RECEIVE FSM and ICACHE/DCACHE FSM
    586     sc_signal<size_t>       r_cc_receive_word_idx;          // word index
    587     GenericFifo<uint32_t>   r_cc_receive_updt_fifo_be;
    588     GenericFifo<uint32_t>   r_cc_receive_updt_fifo_data;
    589     GenericFifo<bool>       r_cc_receive_updt_fifo_eop;
     583    sc_signal<size_t>     r_cc_receive_word_idx;       // word index
     584    GenericFifo<uint32_t> r_cc_receive_updt_fifo_be;
     585    GenericFifo<uint32_t> r_cc_receive_updt_fifo_data;
     586    GenericFifo<bool>     r_cc_receive_updt_fifo_eop;
    590587
    591588    // communication between CC_RECEIVE FSM and ICACHE FSM
    592     sc_signal<bool>         r_cc_receive_icache_req;        // cc_receive to icache request
    593     sc_signal<int>          r_cc_receive_icache_type;       // cc_receive type of request
    594     sc_signal<size_t>       r_cc_receive_icache_way;        // cc_receive to icache way
    595     sc_signal<size_t>       r_cc_receive_icache_set;        // cc_receive to icache set
    596     sc_signal<size_t>       r_cc_receive_icache_updt_tab_idx; // cc_receive update table index
    597     sc_signal<paddr_t>      r_cc_receive_icache_nline;      // cache line physical address
     589    sc_signal<bool>       r_cc_receive_icache_req;          // cc_receive to icache request
     590    sc_signal<int>        r_cc_receive_icache_type;         // cc_receive type of request
     591    sc_signal<size_t>     r_cc_receive_icache_way;          // cc_receive to icache way
     592    sc_signal<size_t>     r_cc_receive_icache_set;          // cc_receive to icache set
     593    sc_signal<size_t>     r_cc_receive_icache_updt_tab_idx; // cc_receive update table index
     594    sc_signal<paddr_t>    r_cc_receive_icache_nline;        // cache line physical address
    598595
    599596    // communication between CC_RECEIVE FSM and DCACHE FSM
    600     sc_signal<bool>         r_cc_receive_dcache_req;              // cc_receive to dcache request
    601     sc_signal<int>          r_cc_receive_dcache_type;             // cc_receive type of request
    602     sc_signal<size_t>       r_cc_receive_dcache_way;              // cc_receive to dcache way
    603     sc_signal<size_t>       r_cc_receive_dcache_set;              // cc_receive to dcache set
    604     sc_signal<size_t>       r_cc_receive_dcache_updt_tab_idx;     // cc_receive update table index
    605     sc_signal<paddr_t>      r_cc_receive_dcache_nline;            // cache line physical address
    606     sc_signal<bool>         r_cc_receive_dcache_inval_is_config; // inval from memcache is config
     597    sc_signal<bool>       r_cc_receive_dcache_req;             // cc_receive to dcache request
     598    sc_signal<int>        r_cc_receive_dcache_type;            // cc_receive type of request
     599    sc_signal<size_t>     r_cc_receive_dcache_way;             // cc_receive to dcache way
     600    sc_signal<size_t>     r_cc_receive_dcache_set;             // cc_receive to dcache set
     601    sc_signal<size_t>     r_cc_receive_dcache_updt_tab_idx;    // cc_receive update table index
     602    sc_signal<paddr_t>    r_cc_receive_dcache_nline;           // cache line physical address
     603    sc_signal<bool>       r_cc_receive_dcache_inval_is_config; // inval from memcache is config
    607604
    608605    ///////////////////////////////////
    609606    //  DSPIN CLACK INTERFACE REGISTER
    610607    ///////////////////////////////////
    611     sc_signal<bool>         r_dspin_clack_req;
    612     sc_signal<uint64_t>     r_dspin_clack_flit;
     608    sc_signal<bool>       r_dspin_clack_req;
     609    sc_signal<uint64_t>   r_dspin_clack_flit;
    613610
    614611    //////////////////////////////////////////////////////////////////
     
    616613    //////////////////////////////////////////////////////////////////
    617614
    618     iss_t                       r_iss;
    619     MultiWriteBuffer<paddr_t>   r_wbuf;
    620     GenericCache<paddr_t>       r_icache;
    621     GenericCache<paddr_t>       r_dcache;
    622     GenericTlb<paddr_t>         r_itlb;
    623     GenericTlb<paddr_t>         r_dtlb;
     615    iss_t                     r_iss;
     616    MultiWriteBuffer<paddr_t> r_wbuf;
     617    GenericCache<paddr_t>     r_icache;
     618    GenericCache<paddr_t>     r_dcache;
     619    GenericTlb<paddr_t>       r_itlb;
     620    GenericTlb<paddr_t>       r_dtlb;
    624621
    625622    //////////////////////////////////////////////////////////////////
     
    627624    //////////////////////////////////////////////////////////////////
    628625
    629     sc_signal<paddr_t>                     r_dcache_llsc_paddr;
    630     sc_signal<uint32_t>                    r_dcache_llsc_key;
    631     sc_signal<uint32_t>                    r_dcache_llsc_count;
    632     sc_signal<bool>                        r_dcache_llsc_valid;
    633 
    634 
    635     sc_signal<bool>                        r_cache_frozen;
     626    sc_signal<paddr_t>  r_dcache_llsc_paddr;
     627    sc_signal<uint32_t> r_dcache_llsc_key;
     628    sc_signal<uint32_t> r_dcache_llsc_count;
     629    sc_signal<bool>     r_dcache_llsc_valid;
    636630
    637631    ////////////////////////////////
    638632    // Activity counters
    639633    ////////////////////////////////
    640     uint32_t m_cpt_dcache_data_read;           // DCACHE DATA READ
    641     uint32_t m_cpt_dcache_data_write;          // DCACHE DATA WRITE
    642     uint32_t m_cpt_dcache_dir_read;            // DCACHE DIR READ
    643     uint32_t m_cpt_dcache_dir_write;           // DCACHE DIR WRITE
    644 
    645     uint32_t m_cpt_icache_data_read;           // ICACHE DATA READ
    646     uint32_t m_cpt_icache_data_write;          // ICACHE DATA WRITE
    647     uint32_t m_cpt_icache_dir_read;            // ICACHE DIR READ
    648     uint32_t m_cpt_icache_dir_write;           // ICACHE DIR WRITE
    649 
    650     uint32_t m_cpt_frz_cycles;                 // number of cycles where the cpu is frozen
    651     uint32_t m_cpt_total_cycles;               // total number of cycles
     634    uint32_t m_cpt_dcache_data_read;        // DCACHE DATA READ
     635    uint32_t m_cpt_dcache_data_write;       // DCACHE DATA WRITE
     636    uint32_t m_cpt_dcache_dir_read;         // DCACHE DIR READ
     637    uint32_t m_cpt_dcache_dir_write;        // DCACHE DIR WRITE
     638
     639    uint32_t m_cpt_icache_data_read;        // ICACHE DATA READ
     640    uint32_t m_cpt_icache_data_write;       // ICACHE DATA WRITE
     641    uint32_t m_cpt_icache_dir_read;         // ICACHE DIR READ
     642    uint32_t m_cpt_icache_dir_write;        // ICACHE DIR WRITE
     643
     644    uint32_t m_cpt_frz_cycles;              // number of cycles where the cpu is frozen
     645    uint32_t m_cpt_total_cycles;            // total number of cycles
    652646
    653647    // Cache activity counters
    654     uint32_t m_cpt_data_read;                  // total number of read data
    655     uint32_t m_cpt_data_write;                 // total number of write data
     648    uint32_t m_cpt_data_read;               // total number of read data
     649    uint32_t m_cpt_data_write;              // total number of write data
    656650    uint32_t m_cpt_data_write_back;
     651    uint32_t m_cpt_data_write_miss;         // number of total write miss
     652    uint32_t m_cpt_data_write_on_zombi;     // number of frozen cycles related to blocked write on ZOMBI line
     653    uint32_t m_cpt_data_write_on_zombi_ncc; // number of frozen cycles related to blocked write on NCC ZOMBI line
    657654    uint32_t m_cpt_data_cleanup;
    658655    uint32_t m_cpt_data_sc;
    659     uint32_t m_cpt_data_miss;                  // number of read miss
    660     uint32_t m_cpt_ins_miss;                   // number of instruction miss
    661     uint32_t m_cpt_unc_read;                   // number of read uncached
    662     uint32_t m_cpt_write_cached;               // number of cached write
    663     uint32_t m_cpt_ins_read;                   // number of instruction read
    664     uint32_t m_cpt_ins_spc_miss;               // number of speculative instruction miss
    665 
    666     uint32_t m_cost_write_frz;                 // number of frozen cycles related to write buffer
    667     uint32_t m_cost_data_miss_frz;             // number of frozen cycles related to data miss
    668     uint32_t m_cost_unc_read_frz;              // number of frozen cycles related to uncached read
    669     uint32_t m_cost_ins_miss_frz;              // number of frozen cycles related to ins miss
    670 
    671     uint32_t m_cpt_imiss_transaction;          // number of VCI instruction miss transactions
    672     uint32_t m_cpt_dmiss_transaction;          // number of VCI data miss transactions
    673     uint32_t m_cpt_unc_transaction;            // number of VCI uncached read transactions
    674     uint32_t m_cpt_dunc_transaction;           // number of VCI uncached read transactions
    675     uint32_t m_cpt_ll_transaction;             // number of VCI uncached read transactions
    676     uint32_t m_cpt_write_transaction;          // number of VCI write transactions
    677     uint32_t m_cpt_icache_unc_transaction;
    678 
    679     uint32_t m_cost_imiss_transaction;         // cumulated duration for VCI IMISS transactions
    680     uint32_t m_cost_dmiss_transaction;         // cumulated duration for VCI DMISS transactions
    681     uint32_t m_cost_unc_transaction;           // cumulated duration for VCI UNC transactions
    682     uint32_t m_cost_write_transaction;         // cumulated duration for VCI WRITE transactions
    683     uint32_t m_cost_icache_unc_transaction;    // cumulated duration for VCI IUNC transactions
    684     uint32_t m_length_write_transaction;       // cumulated length for VCI WRITE transactions
     656    uint32_t m_cpt_dcache_miss;             // number of read miss
     657    uint32_t m_cpt_icache_miss;             // number of instruction miss
     658    uint32_t m_cpt_ins_read;                // number of instruction read
     659
     660    uint32_t m_cost_data_miss_frz;          // number of frozen cycles related to data miss
     661    uint32_t m_cost_ins_miss_frz;           // number of frozen cycles related to ins miss
     662
     663    uint32_t m_cpt_write_transaction;       // number of VCI write transactions
     664    uint32_t m_length_write_transaction;    // cumulated length for VCI WRITE transactions
    685665
    686666    // TLB activity counters
    687     uint32_t m_cpt_ins_tlb_read;               // number of instruction tlb read
    688     uint32_t m_cpt_ins_tlb_miss;               // number of instruction tlb miss
    689     uint32_t m_cpt_ins_tlb_update_acc;         // number of instruction tlb update
    690     uint32_t m_cpt_ins_tlb_occup_cache;        // number of instruction tlb occupy data cache line
    691     uint32_t m_cpt_ins_tlb_hit_dcache;         // number of instruction tlb hit in data cache
    692 
    693     uint32_t m_cpt_data_tlb_read;              // number of data tlb read
    694     uint32_t m_cpt_data_tlb_miss;              // number of data tlb miss
    695     uint32_t m_cpt_data_tlb_update_acc;        // number of data tlb update
    696     uint32_t m_cpt_data_tlb_update_dirty;      // number of data tlb update dirty
    697     uint32_t m_cpt_data_tlb_hit_dcache;        // number of data tlb hit in data cache
    698     uint32_t m_cpt_data_tlb_occup_cache;       // number of data tlb occupy data cache line
     667    uint32_t m_cpt_itlb_read;               // number of instruction tlb read
     668    uint32_t m_cpt_itlb_miss;               // number of instruction tlb miss
     669    uint32_t m_cpt_itlb_write;              // number of instruction tlb update
     670
     671    uint32_t m_cpt_dtlb_read;               // number of data tlb read
     672    uint32_t m_cpt_dtlb_miss;               // number of data tlb miss
     673    uint32_t m_cpt_dtlb_write;              // number of data tlb update
     674
     675    uint32_t m_cost_ins_tlb_miss_frz;       // number of frozen cycles related to instruction tlb miss
     676
     677    // coherence activity counters
     678    uint32_t m_cpt_cleanup_data_not_dirty;  // number of total cleanup data without extra data flits
     679    uint32_t m_cpt_cleanup_data_dirty_word; // number of total words dirty in cleanup data
     680
     681
     682
     683    // counters NOT implemented
     684    uint32_t m_cost_write_frz; // number of frozen cycles related to write buffer
     685    uint32_t m_cost_unc_read_frz; // number of frozen cycles related to uncached read
     686    uint32_t m_cpt_imiss_transaction; // number of VCI instruction miss transactions
     687    uint32_t m_cpt_dmiss_transaction; // number of VCI data miss transactions
     688    uint32_t m_cpt_unc_transaction; // number of VCI uncached read transactions
     689    uint32_t m_cost_imiss_transaction; // cumulated duration for VCI IMISS transactions
     690    uint32_t m_cost_dmiss_transaction; // cumulated duration for VCI DMISS transactions
     691    uint32_t m_cost_unc_transaction; // cumulated duration for VCI UNC transactions
     692    uint32_t m_cost_write_transaction; // cumulated duration for VCI WRITE transactions
     693    uint32_t m_cpt_data_tlb_update_dirty; // number of data tlb update dirty
     694    uint32_t m_cpt_ins_tlb_hit_dcache; // number of instruction tlb hit in data cache
     695    uint32_t m_cpt_data_tlb_hit_dcache; // number of data tlb hit in data cache
     696    uint32_t m_cost_data_tlb_miss_frz; // number of frozen cycles related to data tlb miss
     697    uint32_t m_cost_ins_tlb_update_acc_frz; // number of frozen cycles related to instruction tlb update acc
     698    uint32_t m_cost_data_tlb_update_acc_frz; // number of frozen cycles related to data tlb update acc
     699    uint32_t m_cost_data_tlb_update_dirty_frz; // number of frozen cycles related to data tlb update dirty
     700    uint32_t m_cpt_itlbmiss_transaction; // number of itlb miss transactions
     701    uint32_t m_cpt_dtlbmiss_transaction; // number of dtlb miss transactions
     702    uint32_t m_cost_itlbmiss_transaction; // cumulated duration for VCI instruction TLB miss transactions
     703    uint32_t m_cost_dtlbmiss_transaction; // cumulated duration for VCI data TLB miss transactions
     704    uint32_t m_cpt_cc_broadcast; // number of coherence broadcast commands
     705    uint32_t m_cost_updt_data_frz; // number of frozen cycles related to coherence update data packets
     706    uint32_t m_cost_inval_ins_frz; // number of frozen cycles related to coherence inval instruction packets
     707    uint32_t m_cost_inval_data_frz; // number of frozen cycles related to coherence inval data packets
     708    uint32_t m_cost_broadcast_frz; // number of frozen cycles related to coherence broadcast packets
     709    uint32_t m_cpt_cc_cleanup_data; // number of coherence cleanup packets
     710    uint32_t m_cpt_cc_cleanup_ins; // number of coherence cleanup packets
     711    uint32_t m_cpt_dunc_transaction; // number of VCI uncached read transactions
     712    uint32_t m_cpt_ll_transaction; // number of VCI uncached read transactions
     713    uint32_t m_cpt_cc_update_dcache; // number of coherence update data commands
     714    uint32_t m_cpt_cc_inval_icache; // number of coherence inval instruction commands
     715    uint32_t m_cpt_cc_inval_dcache; // number of coherence inval data commands
     716    uint32_t m_cpt_unc_read; // number of read uncached
     717    uint32_t m_cpt_write_cached; // number of cached write
    699718    uint32_t m_cpt_tlb_occup_dcache;
    700719
    701     uint32_t m_cost_ins_tlb_miss_frz;          // number of frozen cycles related to instruction tlb miss
    702     uint32_t m_cost_data_tlb_miss_frz;         // number of frozen cycles related to data tlb miss
    703     uint32_t m_cost_ins_tlb_update_acc_frz;    // number of frozen cycles related to instruction tlb update acc
    704     uint32_t m_cost_data_tlb_update_acc_frz;   // number of frozen cycles related to data tlb update acc
    705     uint32_t m_cost_data_tlb_update_dirty_frz; // number of frozen cycles related to data tlb update dirty
    706     uint32_t m_cost_ins_tlb_occup_cache_frz;   // number of frozen cycles related to instruction tlb miss operate in dcache
    707     uint32_t m_cost_data_tlb_occup_cache_frz;  // number of frozen cycles related to data tlb miss operate in dcache
    708 
    709     uint32_t m_cpt_itlbmiss_transaction;       // number of itlb miss transactions
    710     uint32_t m_cpt_itlb_ll_transaction;        // number of itlb ll acc transactions
    711     uint32_t m_cpt_itlb_sc_transaction;        // number of itlb sc acc transactions
    712     uint32_t m_cpt_dtlbmiss_transaction;       // number of dtlb miss transactions
    713     uint32_t m_cpt_dtlb_ll_transaction;        // number of dtlb ll acc transactions
    714     uint32_t m_cpt_dtlb_sc_transaction;        // number of dtlb sc acc transactions
    715     uint32_t m_cpt_dtlb_ll_dirty_transaction;  // number of dtlb ll dirty transactions
    716     uint32_t m_cpt_dtlb_sc_dirty_transaction;  // number of dtlb sc dirty transactions
    717 
    718     uint32_t m_cost_itlbmiss_transaction;      // cumulated duration for VCI instruction TLB miss transactions
    719     uint32_t m_cost_itlb_ll_transaction;       // cumulated duration for VCI instruction TLB ll acc transactions
    720     uint32_t m_cost_itlb_sc_transaction;       // cumulated duration for VCI instruction TLB sc acc transactions
    721     uint32_t m_cost_dtlbmiss_transaction;      // cumulated duration for VCI data TLB miss transactions
    722     uint32_t m_cost_dtlb_ll_transaction;       // cumulated duration for VCI data TLB ll acc transactions
    723     uint32_t m_cost_dtlb_sc_transaction;       // cumulated duration for VCI data TLB sc acc transactions
    724     uint32_t m_cost_dtlb_ll_dirty_transaction; // cumulated duration for VCI data TLB ll dirty transactions
    725     uint32_t m_cost_dtlb_sc_dirty_transaction; // cumulated duration for VCI data TLB sc dirty transactions
    726 
    727     // coherence activity counters
    728     uint32_t m_cpt_cc_update_icache;           // number of coherence update instruction commands
    729     uint32_t m_cpt_cc_update_dcache;           // number of coherence update data commands
    730     uint32_t m_cpt_cc_inval_icache;            // number of coherence inval instruction commands
    731     uint32_t m_cpt_cc_inval_dcache;            // number of coherence inval data commands
    732     uint32_t m_cpt_cc_broadcast;               // number of coherence broadcast commands
    733 
    734     uint32_t m_cost_updt_data_frz;             // number of frozen cycles related to coherence update data packets
    735     uint32_t m_cost_inval_ins_frz;             // number of frozen cycles related to coherence inval instruction packets
    736     uint32_t m_cost_inval_data_frz;            // number of frozen cycles related to coherence inval data packets
    737     uint32_t m_cost_broadcast_frz;             // number of frozen cycles related to coherence broadcast packets
    738 
    739     uint32_t m_cpt_cc_cleanup_ins;             // number of coherence cleanup packets
    740     uint32_t m_cpt_cc_cleanup_data;            // number of coherence cleanup packets
    741     uint32_t m_cpt_cleanup_data_not_dirty;     // number of total cleanup data without extra data flits
    742     uint32_t m_cpt_cleanup_data_dirty_word;    // number of total words dirty in cleanup data
    743     uint32_t m_cpt_data_write_miss;            // number of total write miss
    744     uint32_t m_cpt_data_write_on_zombi;        // number of frozen cycles related to blocked write on line NCC/CC ZOMBI
    745     uint32_t m_cpt_data_write_on_zombi_ncc;    // number of frozen cycles related to blocked write on line NCC ZOMBI
    746 
    747     uint32_t m_cpt_icleanup_transaction;       // number of instruction cleanup transactions
    748     uint32_t m_cpt_dcleanup_transaction;       // number of instructinumber of data cleanup transactions
    749     uint32_t m_cost_icleanup_transaction;      // cumulated duration for VCI instruction cleanup transactions
    750     uint32_t m_cost_dcleanup_transaction;      // cumulated duration for VCI data cleanup transactions
    751 
    752     uint32_t m_cost_ins_tlb_inval_frz;         // number of frozen cycles related to checking ins tlb invalidate
    753     uint32_t m_cpt_ins_tlb_inval;              // number of ins tlb invalidate
    754 
    755     uint32_t m_cost_data_tlb_inval_frz;        // number of frozen cycles related to checking data tlb invalidate
    756     uint32_t m_cpt_data_tlb_inval;             // number of data tlb invalidate
    757720
    758721    // FSM activity counters
     
    764727    uint32_t m_cpt_fsm_cc_send    [64];
    765728
    766     uint32_t m_cpt_stop_simulation;     // used to stop simulation if frozen
    767     bool     m_monitor_ok;              // used to debug cache output
     729    uint32_t m_cpt_stop_simulation; // used to stop simulation if frozen
     730    bool     m_monitor_ok;          // used to debug cache output
    768731    uint32_t m_monitor_base;
    769732    uint32_t m_monitor_length;
     
    774737public:
    775738    VciCcVCacheWrapper(
    776         sc_module_name                      name,
    777         const int                           proc_id,
    778         const soclib::common::MappingTable  &mtd,
    779         const soclib::common::IntTab        &srcid,
    780         const size_t                        cc_global_id,
    781         const size_t                        itlb_ways,
    782         const size_t                        itlb_sets,
    783         const size_t                        dtlb_ways,
    784         const size_t                        dtlb_sets,
    785         const size_t                        icache_ways,
    786         const size_t                        icache_sets,
    787         const size_t                        icache_words,
    788         const size_t                        dcache_ways,
    789         const size_t                        dcache_sets,
    790         const size_t                        dcache_words,
    791         const size_t                        wbuf_nlines,
    792         const size_t                        wbuf_nwords,
    793         const size_t                        x_width,
    794         const size_t                        y_width,
    795         const uint32_t                      max_frozen_cycles,
    796         const uint32_t                      debug_start_cycle,
    797         const bool                          debug_ok );
     739        sc_module_name                     name,
     740        const int                          proc_id,
     741        const soclib::common::MappingTable &mtd,
     742        const soclib::common::IntTab       &srcid,
     743        const size_t                       cc_global_id,
     744        const size_t                       itlb_ways,
     745        const size_t                       itlb_sets,
     746        const size_t                       dtlb_ways,
     747        const size_t                       dtlb_sets,
     748        const size_t                       icache_ways,
     749        const size_t                       icache_sets,
     750        const size_t                       icache_words,
     751        const size_t                       dcache_ways,
     752        const size_t                       dcache_sets,
     753        const size_t                       dcache_words,
     754        const size_t                       wbuf_nlines,
     755        const size_t                       wbuf_nwords,
     756        const size_t                       x_width,
     757        const size_t                       y_width,
     758        const uint32_t                     max_frozen_cycles,
     759        const uint32_t                     debug_start_cycle,
     760        const bool                         debug_ok );
    798761
    799762    ~VciCcVCacheWrapper();
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r824 r827  
    3737#define DEBUG_ICACHE        1
    3838#define DEBUG_CMD           0
    39 #define INSTRUMENTATION     1
    4039
    4140namespace soclib {
     
    4342
    4443namespace {
    45 const char *icache_fsm_state_str[] = {
     44const char * icache_fsm_state_str[] = {
    4645        "ICACHE_IDLE",
    4746
     
    6968    };
    7069
    71 const char *dcache_fsm_state_str[] = {
     70const char * dcache_fsm_state_str[] = {
    7271        "DCACHE_IDLE",
    7372
     
    122121    };
    123122
    124 const char *cmd_fsm_state_str[] = {
     123const char * cmd_fsm_state_str[] = {
    125124        "CMD_IDLE",
    126125        "CMD_INS_MISS",
     
    135134    };
    136135
    137 const char *vci_pktid_type_str[] = {
     136const char * vci_pktid_type_str[] = {
    138137        "TYPE_DATA_UNC",
    139138        "TYPE_READ_DATA_MISS",
     
    146145    };
    147146
    148 const char *vci_cmd_type_str[] = {
     147const char * vci_cmd_type_str[] = {
    149148        "NOP or STORE_COND",
    150149        "READ",
     
    153152    };
    154153
    155 const char *rsp_fsm_state_str[] = {
     154const char * rsp_fsm_state_str[] = {
    156155        "RSP_IDLE",
    157156        "RSP_INS_MISS",
     
    163162    };
    164163
    165 const char *cc_receive_fsm_state_str[] = {
     164const char * cc_receive_fsm_state_str[] = {
    166165        "CC_RECEIVE_IDLE",
    167166        "CC_RECEIVE_BRDCAST_HEADER",
     
    179178    };
    180179
    181 const char *cc_send_fsm_state_str[] = {
     180const char * cc_send_fsm_state_str[] = {
    182181        "CC_SEND_IDLE",
    183182        "CC_SEND_CLEANUP_1",
     
    199198/////////////////////////////////
    200199tmpl(/**/)::VciCcVCacheWrapper(
    201     sc_module_name          name,
    202     const int               proc_id,
    203     const MappingTable      &mtd,
    204     const IntTab            &srcid,
    205     const size_t            cc_global_id,
    206     const size_t            itlb_ways,
    207     const size_t            itlb_sets,
    208     const size_t            dtlb_ways,
    209     const size_t            dtlb_sets,
    210     const size_t            icache_ways,
    211     const size_t            icache_sets,
    212     const size_t            icache_words,
    213     const size_t            dcache_ways,
    214     const size_t            dcache_sets,
    215     const size_t            dcache_words,
    216     const size_t            wbuf_nlines,
    217     const size_t            wbuf_nwords,
    218     const size_t            x_width,
    219     const size_t            y_width,
    220     const uint32_t          max_frozen_cycles,
    221     const uint32_t          debug_start_cycle,
    222     const bool              debug_ok )
     200    sc_module_name     name,
     201    const int          proc_id,
     202    const MappingTable &mtd,
     203    const IntTab       &srcid,
     204    const size_t       cc_global_id,
     205    const size_t       itlb_ways,
     206    const size_t       itlb_sets,
     207    const size_t       dtlb_ways,
     208    const size_t       dtlb_sets,
     209    const size_t       icache_ways,
     210    const size_t       icache_sets,
     211    const size_t       icache_words,
     212    const size_t       dcache_ways,
     213    const size_t       dcache_sets,
     214    const size_t       dcache_words,
     215    const size_t       wbuf_nlines,
     216    const size_t       wbuf_nwords,
     217    const size_t       x_width,
     218    const size_t       y_width,
     219    const uint32_t     max_frozen_cycles,
     220    const uint32_t     debug_start_cycle,
     221    const bool         debug_ok)
    223222    : soclib::caba::BaseModule(name),
    224223
     
    230229      p_dspin_clack("p_dspin_clack"),
    231230
    232       m_cacheability_table( mtd.getCacheabilityTable() ),
    233       m_srcid( mtd.indexForId(srcid) ),
    234       m_cc_global_id( cc_global_id ),
    235       m_nline_width( vci_param::N - (uint32_log2(dcache_words)) - 2 ),
    236       m_itlb_ways( itlb_ways ),
    237       m_itlb_sets( itlb_sets ),
    238       m_dtlb_ways( dtlb_ways ),
    239       m_dtlb_sets( dtlb_sets ),
    240       m_icache_ways( icache_ways ),
    241       m_icache_sets( icache_sets ),
    242       m_icache_yzmask( (~0)<<(uint32_log2(icache_words) + 2) ),
    243       m_icache_words( icache_words ),
    244       m_dcache_ways( dcache_ways ),
    245       m_dcache_sets( dcache_sets ),
    246       m_dcache_yzmask( (~0)<<(uint32_log2(dcache_words) + 2) ),
    247       m_dcache_words( dcache_words ),
    248       m_x_width( x_width ),
    249       m_y_width( y_width ),
    250       m_proc_id( proc_id ),
    251       m_max_frozen_cycles( max_frozen_cycles ),
    252       m_paddr_nbits( vci_param::N ),
    253       m_debug_start_cycle( debug_start_cycle ),
    254       m_debug_ok( debug_ok ),
     231      m_cacheability_table(mtd.getCacheabilityTable()),
     232      m_srcid(mtd.indexForId(srcid)),
     233      m_cc_global_id(cc_global_id),
     234      m_nline_width(vci_param::N - (uint32_log2(dcache_words)) - 2),
     235      m_itlb_ways(itlb_ways),
     236      m_itlb_sets(itlb_sets),
     237      m_dtlb_ways(dtlb_ways),
     238      m_dtlb_sets(dtlb_sets),
     239      m_icache_ways(icache_ways),
     240      m_icache_sets(icache_sets),
     241      m_icache_yzmask((~0) << (uint32_log2(icache_words) + 2)),
     242      m_icache_words(icache_words),
     243      m_dcache_ways(dcache_ways),
     244      m_dcache_sets(dcache_sets),
     245      m_dcache_yzmask((~0) << (uint32_log2(dcache_words) + 2)),
     246      m_dcache_words(dcache_words),
     247      m_x_width(x_width),
     248      m_y_width(y_width),
     249      m_proc_id(proc_id),
     250      m_max_frozen_cycles(max_frozen_cycles),
     251      m_paddr_nbits(vci_param::N),
     252      m_debug_start_cycle(debug_start_cycle),
     253      m_debug_ok(debug_ok),
    255254      m_dcache_paddr_ext_reset(0),
    256255      m_icache_paddr_ext_reset(0),
     
    281280      r_icache_cc_need_write("r_icache_cc_need_write"),
    282281
     282      r_icache_clack_req("r_icache_clack_req"),
     283      r_icache_clack_way("r_icache_clack_way"),
     284      r_icache_clack_set("r_icache_clack_set"),
     285
    283286      r_icache_flush_count("r_icache_flush_count"),
    284287
     
    286289      r_icache_unc_req("r_icache_unc_req"),
    287290
    288       r_icache_tlb_miss_req("r_icache_tlb_read_req"),
     291      r_icache_tlb_miss_req("r_icache_tlb_miss_req"),
    289292      r_icache_tlb_rsp_error("r_icache_tlb_rsp_error"),
    290293
     
    297300      r_icache_cc_send_way("r_icache_cc_send_way"),
    298301      r_icache_cc_send_updt_tab_idx("r_icache_cc_send_updt_tab_idx"),
     302
     303      r_icache_paddr_ext("r_icache_paddr_ext"),
    299304
    300305      r_dcache_fsm("r_dcache_fsm"),
     
    329334      r_dcache_vci_sc_data("r_dcache_vci_sc_data"),
    330335
     336      r_cas_islocal("r_cas_islocal"),
     337      r_cas_local_way("r_cas_local_way"),
     338      r_cas_local_set("r_cas_local_set"),
     339      r_cas_local_word("r_cas_local_word"),
     340
    331341      r_dcache_xtn_way("r_dcache_xtn_way"),
    332342      r_dcache_xtn_set("r_dcache_xtn_set"),
     
    337347      r_dcache_miss_set("r_dcache_miss_set"),
    338348      r_dcache_miss_inval("r_dcache_miss_inval"),
     349      r_dcache_miss_clack("r_dcache_miss_clack"),
    339350
    340351      r_dcache_cc_way("r_dcache_cc_way"),
    341352      r_dcache_cc_set("r_dcache_cc_set"),
     353      r_dcache_cc_state("r_dcache_cc_state"),
    342354      r_dcache_cc_word("r_dcache_cc_word"),
    343355      r_dcache_cc_need_write("r_dcache_cc_need_write"),
     356      r_dcache_cc_inval_addr("r_dcache_cc_inval_addr"),
     357      r_dcache_cc_inval_data_cpt("r_dcache_cc_inval_data_cpt"),
     358
     359      r_dcache_clack_req("r_dcache_clack_req"),
     360      r_dcache_clack_way("r_dcache_clack_way"),
     361      r_dcache_clack_set("r_dcache_clack_set"),
    344362
    345363      r_dcache_flush_count("r_dcache_flush_count"),
     
    349367      r_dcache_tlb_vaddr("r_dcache_tlb_vaddr"),
    350368      r_dcache_tlb_ins("r_dcache_tlb_ins"),
     369      r_dcache_tlb_paddr("r_dcache_tlb_paddr"),
    351370      r_dcache_tlb_pte_flags("r_dcache_tlb_pte_flags"),
    352371      r_dcache_tlb_pte_ppn("r_dcache_tlb_pte_ppn"),
     372      r_dcache_tlb_cache_way("r_dcache_tlb_cache_way"),
     373      r_dcache_tlb_cache_set("r_dcache_tlb_cache_set"),
     374      r_dcache_tlb_cache_word("r_dcache_tlb_cache_word"),
    353375      r_dcache_tlb_way("r_dcache_tlb_way"),
    354376      r_dcache_tlb_set("r_dcache_tlb_set"),
     
    361383
    362384      r_dcache_cleanup_victim_req("r_dcache_cleanup_victim_req"),
     385      r_dcache_cleanup_victim_line_ncc("r_dcache_cleanup_victim_line_ncc"),
     386      r_dcache_cleanup_victim_updt_data("r_dcache_cleanup_victim_updt_data"),
    363387      r_dcache_cleanup_victim_nline("r_dcache_cleanup_victim_nline"),
    364388
     
    369393      r_dcache_cc_send_updt_tab_idx("r_dcache_cc_send_updt_tab_idx"),
    370394
     395      r_dcache_cc_cleanup_updt_data("r_dcache_cc_cleanup_updt_data"),
     396      r_dcache_cc_cleanup_line_ncc("r_dcache_cc_cleanup_line_ncc"),
     397      r_dcache_dirty_save("r_dcache_dirty_save"),
     398      r_cc_send_cpt_word("r_cc_send_cpt_word"),
     399      r_dcache_miss_data_cpt("r_dcache_miss_data_cpt"),
     400      r_dcache_miss_data_addr("r_dcache_miss_data_addr"),
     401      r_dcache_xtn_flush_data_cpt("r_dcache_xtn_flush_data_cpt"),
     402      r_dcache_xtn_flush_addr_data("r_dcache_xtn_flush_addr_data"),
     403      r_dcache_xtn_state("r_dcache_xtn_state"),
     404      r_dcache_xtn_data_addr("r_dcache_xtn_data_addr"),
     405      r_dcache_xtn_data_cpt("r_dcache_xtn_data_cpt"),
     406      r_dcache_read_state("r_dcache_read_state"),
     407
     408      r_dcache_paddr_ext("r_dcache_paddr_ext"),
     409
    371410      r_vci_cmd_fsm("r_vci_cmd_fsm"),
    372411      r_vci_cmd_min("r_vci_cmd_min"),
     
    379418      r_vci_rsp_ins_error("r_vci_rsp_ins_error"),
    380419      r_vci_rsp_data_error("r_vci_rsp_data_error"),
    381       r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2),    // 2 words depth
    382       r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2),    // 2 words depth
    383       r_vci_rsp_fifo_rpktid("r_vci_rsp_fifo_rpktid", 2),    // 2 words depth
     420      r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2), // 2 words depth
     421      r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2), // 2 words depth
     422      r_vci_rsp_fifo_rpktid("r_vci_rsp_fifo_rpktid", 2), // 2 words depth
    384423      r_cc_send_data_fifo("r_cc_send_data_fifo", 16),
    385424
     
    407446      r_cc_receive_dcache_updt_tab_idx("r_cc_receive_dcache_updt_tab_idx"),
    408447      r_cc_receive_dcache_nline("r_cc_receive_dcache_nline"),
     448      r_cc_receive_dcache_inval_is_config("r_cc_receive_dcache_inval_is_config"),
     449
     450      r_dspin_clack_req("r_dspin_clack_req"),
     451      r_dspin_clack_flit("r_dspin_clack_flit"),
    409452
    410453      r_iss(this->name(), proc_id),
     
    412455      r_icache("icache", icache_ways, icache_sets, icache_words),
    413456      r_dcache("dcache", dcache_ways, dcache_sets, dcache_words),
    414       r_itlb("itlb", proc_id, itlb_ways,itlb_sets,vci_param::N),
    415       r_dtlb("dtlb", proc_id, dtlb_ways,dtlb_sets,vci_param::N)
     457      r_itlb("itlb", proc_id, itlb_ways, itlb_sets, vci_param::N),
     458      r_dtlb("dtlb", proc_id, dtlb_ways, dtlb_sets, vci_param::N),
     459
     460      r_dcache_llsc_paddr("r_dcache_llsc_paddr"),
     461      r_dcache_llsc_key("r_dcache_llsc_key"),
     462      r_dcache_llsc_count("r_dcache_llsc_count"),
     463      r_dcache_llsc_valid("r_dcache_llsc_valid")
    416464{
    417465    std::cout << "  - Building VciCcVcacheWrapper : " << name << std::endl;
    418466
    419     assert( ((icache_words*vci_param::B) < (1<<vci_param::K)) and
     467    assert(((icache_words*vci_param::B) < (1 << vci_param::K)) and
    420468             "Need more PLEN bits.");
    421469
    422     assert( (vci_param::T > 2) and ((1<<(vci_param::T-1)) >= (wbuf_nlines)) and
     470    assert((vci_param::T > 2) and ((1 << (vci_param::T - 1)) >= (wbuf_nlines)) and
    423471             "Need more TRDID bits.");
    424472
    425     assert( (icache_words == dcache_words) and
     473    assert((icache_words == dcache_words) and
    426474             "icache_words and dcache_words parameters must be equal");
    427475
    428     assert( (itlb_sets == dtlb_sets) and
     476    assert((itlb_sets == dtlb_sets) and
    429477             "itlb_sets and dtlb_sets parameters must be equal");
    430478
    431     assert( (itlb_ways == dtlb_ways) and
     479    assert((itlb_ways == dtlb_ways) and
    432480             "itlb_ways and dtlb_ways parameters must be equal");
    433481
     
    436484                   (uint32_log2(m_itlb_ways)   << 15)   | (uint32_log2(m_itlb_sets)   << 11) |
    437485                   (uint32_log2(m_icache_ways) << 8)    | (uint32_log2(m_icache_sets) << 4)  |
    438                    (uint32_log2(m_icache_words<<2));
    439 
    440     r_mmu_release = (uint32_t)(1 << 16) | 0x1;
    441 
    442     ////////////////////MODIFIED///////////////////////////////
    443     //r_dcache_in_tlb        = new bool[dcache_ways*dcache_sets];
    444     //r_dcache_contains_ptd  = new bool[dcache_ways*dcache_sets];
    445     r_dcache_content_state = new int  [dcache_ways*dcache_sets];
    446     r_dcache_dirty_word    = new int  [dcache_ways*dcache_sets*dcache_words];
    447     r_dcache_zombi_ncc     = new bool [dcache_ways*dcache_sets];
    448     ///////////////////////////////////////////////////////////
     486                   (uint32_log2(m_icache_words << 2));
     487
     488    r_mmu_release = (uint32_t) (1 << 16) | 0x1;
     489
     490    r_dcache_content_state = new int[dcache_ways * dcache_sets];
     491    r_dcache_dirty_word    = new int[dcache_ways * dcache_sets * dcache_words];
     492    r_dcache_zombi_ncc     = new bool[dcache_ways * dcache_sets];
    449493
    450494
     
    459503    typename iss_t::CacheInfo cache_info;
    460504    cache_info.has_mmu = true;
    461     cache_info.icache_line_size = icache_words*sizeof(uint32_t);
     505    cache_info.icache_line_size = icache_words * sizeof(uint32_t);
    462506    cache_info.icache_assoc = icache_ways;
    463507    cache_info.icache_n_lines = icache_sets;
    464     cache_info.dcache_line_size = dcache_words*sizeof(uint32_t);
     508    cache_info.dcache_line_size = dcache_words * sizeof(uint32_t);
    465509    cache_info.dcache_assoc = dcache_ways;
    466510    cache_info.dcache_n_lines = dcache_sets;
     
    475519    delete [] r_dcache_dirty_word;
    476520    delete [] r_dcache_zombi_ncc;
    477     /////////////////////////////////
    478     //print_stats();
    479521}
    480522
     
    515557              << " | MMU = " << r_mmu_mode.read();
    516558
    517     if (r_dcache_updt_req.read() ) std::cout << " | P1_UPDT";
    518     if (r_dcache_wbuf_req.read() ) std::cout << " | P1_WBUF";
     559    if (r_dcache_updt_req.read()) std::cout << " | P1_UPDT";
     560    if (r_dcache_wbuf_req.read()) std::cout << " | P1_WBUF";
    519561    std::cout << std::endl;
    520562
    521     if(mode & 0x01)
    522     {
    523         if ( r_icache_miss_req.read()     ) std::cout << "  IMISS_REQ" << std::endl;
    524         if ( r_icache_unc_req.read()      ) std::cout << "  IUNC_REQ" << std::endl;
    525         if ( r_dcache_vci_miss_req.read() ) std::cout << "  DMISS_REQ" << std::endl;
    526         if ( r_dcache_vci_unc_req.read()  ) std::cout << "  DUNC_REQ" << std::endl;
    527 
    528         r_wbuf.printTrace((mode>>1)&1);
    529     }
    530     if(mode & 0x02)
     563    if (mode & 0x01)
     564    {
     565        if (r_icache_miss_req.read())    std::cout << "  IMISS_REQ" << std::endl;
     566        if (r_icache_unc_req.read())      std::cout << "  IUNC_REQ" << std::endl;
     567        if (r_dcache_vci_miss_req.read()) std::cout << "  DMISS_REQ" << std::endl;
     568        if (r_dcache_vci_unc_req.read()) std::cout << "  DUNC_REQ" << std::endl;
     569
     570        r_wbuf.printTrace((mode >> 1) & 1);
     571    }
     572    if (mode & 0x02)
    531573    {
    532574        r_iss.dump();
    533575    }
    534     if(mode & 0x04)
     576    if (mode & 0x04)
    535577    {
    536578        std::cout << "  Data Cache" << std::endl;
    537579        r_dcache.printTrace();
    538580    }
    539     if(mode & 0x08)
     581    if (mode & 0x08)
    540582    {
    541583        std::cout << "  Instruction Cache" << std::endl;
    542584        r_icache.printTrace();
    543585    }
    544     if(mode & 0x10)
     586    if (mode & 0x10)
    545587    {
    546588        std::cout << "  Data TLB" << std::endl;
    547589        r_dtlb.printTrace();
    548590    }
    549     if(mode & 0x20)
     591    if (mode & 0x20)
    550592    {
    551593        std::cout << "  Instruction TLB" << std::endl;
     
    555597
    556598//////////////////////////////////////////
    557 tmpl(void)::cache_monitor( paddr_t addr )
     599tmpl(void)::cache_monitor(paddr_t addr)
    558600//////////////////////////////////////////
    559601{
    560     bool        cache_hit;
    561     size_t      cache_way = 0;
    562     size_t      cache_set = 0;
    563     size_t      cache_word = 0;
    564     uint32_t    cache_rdata = 0;
    565 
    566     cache_hit = r_dcache.read_neutral( addr,
    567                                        &cache_rdata,
    568                                        &cache_way,
    569                                        &cache_set,
    570                                        &cache_word );
    571 
    572     if ( cache_hit != m_debug_previous_d_hit )
     602    bool cache_hit;
     603    size_t cache_way = 0;
     604    size_t cache_set = 0;
     605    size_t cache_word = 0;
     606    uint32_t cache_rdata = 0;
     607
     608    cache_hit = r_dcache.read_neutral(addr,
     609                                      &cache_rdata,
     610                                      &cache_way,
     611                                      &cache_set,
     612                                      &cache_word);
     613
     614    if (cache_hit != m_debug_previous_d_hit)
    573615    {
    574616        std::cout << "Monitor PROC " << name()
     
    581623    }
    582624
    583     cache_hit = r_icache.read_neutral( addr,
    584                                        &cache_rdata,
    585                                        &cache_way,
    586                                        &cache_set,
    587                                        &cache_word );
    588 
    589     if ( cache_hit != m_debug_previous_i_hit )
     625    cache_hit = r_icache.read_neutral(addr,
     626                                      &cache_rdata,
     627                                      &cache_way,
     628                                      &cache_set,
     629                                      &cache_word);
     630
     631    if (cache_hit != m_debug_previous_i_hit)
    590632    {
    591633        std::cout << "Monitor PROC " << name()
     
    609651        << "- READ RATE               = " << (float)m_cpt_data_read/run_cycles << std::endl
    610652        << "- WRITE RATE              = " << (float)m_cpt_data_write/run_cycles << std::endl
    611         << "- IMISS_RATE              = " << (float)m_cpt_ins_miss/m_cpt_ins_read << std::endl
    612         << "- DMISS RATE              = " << (float)m_cpt_data_miss/(m_cpt_data_read-m_cpt_unc_read) << std::endl
    613         << "- INS MISS COST           = " << (float)m_cost_ins_miss_frz/m_cpt_ins_miss << std::endl
    614         << "- DATA MISS COST          = " << (float)m_cost_data_miss_frz/m_cpt_data_miss << std::endl
     653        << "- IMISS_RATE              = " << (float)m_cpt_icache_miss/m_cpt_ins_read << std::endl
     654        << "- DMISS RATE              = " << (float)m_cpt_dcache_miss/(m_cpt_data_read-m_cpt_unc_read) << std::endl
     655        << "- INS MISS COST           = " << (float)m_cost_ins_miss_frz/m_cpt_icache_miss << std::endl
     656        << "- DATA MISS COST          = " << (float)m_cost_data_miss_frz/m_cpt_dcache_miss << std::endl
    615657        << "- WRITE COST              = " << (float)m_cost_write_frz/m_cpt_data_write << std::endl
    616658        << "- UNC COST                = " << (float)m_cost_unc_read_frz/m_cpt_unc_read << std::endl
    617659        << "- UNCACHED READ RATE      = " << (float)m_cpt_unc_read/m_cpt_data_read << std::endl
    618660        << "- CACHED WRITE RATE       = " << (float)m_cpt_write_cached/m_cpt_data_write << std::endl
    619         << "- INS TLB MISS RATE       = " << (float)m_cpt_ins_tlb_miss/m_cpt_ins_tlb_read << std::endl
    620         << "- DATA TLB MISS RATE      = " << (float)m_cpt_data_tlb_miss/m_cpt_data_tlb_read << std::endl
    621         << "- ITLB MISS COST          = " << (float)m_cost_ins_tlb_miss_frz/m_cpt_ins_tlb_miss << std::endl
    622         << "- DTLB MISS COST          = " << (float)m_cost_data_tlb_miss_frz/m_cpt_data_tlb_miss << std::endl
    623         << "- ITLB UPDATE ACC COST    = " << (float)m_cost_ins_tlb_update_acc_frz/m_cpt_ins_tlb_update_acc << std::endl
    624         << "- DTLB UPDATE ACC COST    = " << (float)m_cost_data_tlb_update_acc_frz/m_cpt_data_tlb_update_acc << std::endl
     661        << "- INS TLB MISS RATE       = " << (float)m_cpt_itlb_miss/m_cpt_itlb_read << std::endl
     662        << "- DATA TLB MISS RATE      = " << (float)m_cpt_dtlb_miss/m_cpt_dtlb_read << std::endl
     663        << "- ITLB MISS COST          = " << (float)m_cost_ins_tlb_miss_frz/m_cpt_itlb_miss << std::endl
     664        << "- DTLB MISS COST          = " << (float)m_cost_data_tlb_miss_frz/m_cpt_dtlb_miss << std::endl
     665        << "- ITLB UPDATE ACC COST    = " << (float)m_cost_ins_tlb_update_acc_frz/m_cpt_itlb_write << std::endl
     666        << "- DTLB UPDATE ACC COST    = " << (float)m_cost_data_tlb_update_acc_frz/m_cpt_dtlb_write << std::endl
    625667        << "- DTLB UPDATE DIRTY COST  = " << (float)m_cost_data_tlb_update_dirty_frz/m_cpt_data_tlb_update_dirty << std::endl
    626         << "- ITLB HIT IN DCACHE RATE = " << (float)m_cpt_ins_tlb_hit_dcache/m_cpt_ins_tlb_miss << std::endl
    627         << "- DTLB HIT IN DCACHE RATE = " << (float)m_cpt_data_tlb_hit_dcache/m_cpt_data_tlb_miss << std::endl
    628         //<< "- DCACHE FROZEN BY ITLB   = " << (float)m_cost_ins_tlb_occup_cache_frz/m_cpt_dcache_frz_cycles << std::endl
     668        << "- ITLB HIT IN DCACHE RATE = " << (float)m_cpt_ins_tlb_hit_dcache/m_cpt_itlb_miss << std::endl
     669        << "- DTLB HIT IN DCACHE RATE = " << (float)m_cpt_data_tlb_hit_dcache/m_cpt_dtlb_miss << std::endl
    629670        << "- DCACHE FOR TLB %        = " << (float)m_cpt_tlb_occup_dcache/(m_dcache_ways*m_dcache_sets) << std::endl
    630671        << "- NB CC BROADCAST         = " << m_cpt_cc_broadcast << std::endl
     
    666707////////////////////////
    667708{
    668     m_cpt_dcache_data_read  = 0;
     709    m_cpt_dcache_data_read = 0;
    669710    m_cpt_dcache_data_write = 0;
    670     m_cpt_dcache_dir_read   = 0;
    671     m_cpt_dcache_dir_write  = 0;
    672     m_cpt_icache_data_read  = 0;
     711    m_cpt_dcache_dir_read = 0;
     712    m_cpt_dcache_dir_write = 0;
     713    m_cpt_icache_data_read = 0;
    673714    m_cpt_icache_data_write = 0;
    674     m_cpt_icache_dir_read   = 0;
    675     m_cpt_icache_dir_write  = 0;
    676 
    677     m_cpt_frz_cycles        = 0;
    678 //    m_cpt_dcache_frz_cycles = 0;
    679     m_cpt_total_cycles      = 0;
    680 
    681 //    m_cpt_read        = 0;
    682 //    m_cpt_write        = 0;
    683     m_cpt_data_miss    = 0;
    684     m_cpt_ins_miss    = 0;
    685     m_cpt_unc_read     = 0;
    686     m_cpt_write_cached = 0;
    687     m_cpt_ins_read    = 0;
    688 
    689     m_cost_write_frz     = 0;
     715    m_cpt_icache_dir_read = 0;
     716    m_cpt_icache_dir_write = 0;
     717
     718    m_cpt_frz_cycles = 0;
     719    m_cpt_total_cycles = 0;
     720
     721    m_cpt_data_read = 0;
     722    m_cpt_data_write = 0;
     723    m_cpt_data_write_back = 0;
     724    m_cpt_data_cleanup = 0;
     725    m_cpt_data_sc = 0;
     726
     727    m_cpt_dcache_miss = 0;
     728    m_cpt_icache_miss = 0;
     729    m_cpt_ins_read = 0;
     730
    690731    m_cost_data_miss_frz = 0;
    691     m_cost_unc_read_frz  = 0;
    692     m_cost_ins_miss_frz  = 0;
    693 
    694     m_cpt_imiss_transaction      = 0;
    695     m_cpt_dmiss_transaction      = 0;
    696     m_cpt_unc_transaction        = 0;
    697     m_cpt_write_transaction      = 0;
    698     m_cpt_icache_unc_transaction = 0;
    699 
    700     m_cost_imiss_transaction      = 0;
    701     m_cost_dmiss_transaction      = 0;
    702     m_cost_unc_transaction        = 0;
    703     m_cost_write_transaction      = 0;
    704     m_cost_icache_unc_transaction = 0;
    705     m_length_write_transaction    = 0;
    706 
    707     m_cpt_ins_tlb_read       = 0;
    708     m_cpt_ins_tlb_miss       = 0;
    709     m_cpt_ins_tlb_update_acc = 0;
    710 
    711     m_cpt_data_tlb_read         = 0;
    712     m_cpt_data_tlb_miss         = 0;
    713     m_cpt_data_tlb_update_acc   = 0;
    714     m_cpt_data_tlb_update_dirty = 0;
    715     m_cpt_ins_tlb_hit_dcache    = 0;
    716     m_cpt_data_tlb_hit_dcache   = 0;
    717     m_cpt_ins_tlb_occup_cache   = 0;
    718     m_cpt_data_tlb_occup_cache  = 0;
    719 
    720     m_cost_ins_tlb_miss_frz          = 0;
    721     m_cost_data_tlb_miss_frz         = 0;
    722     m_cost_ins_tlb_update_acc_frz    = 0;
    723     m_cost_data_tlb_update_acc_frz   = 0;
    724     m_cost_data_tlb_update_dirty_frz = 0;
    725     m_cost_ins_tlb_occup_cache_frz   = 0;
    726     m_cost_data_tlb_occup_cache_frz  = 0;
    727 
    728     m_cpt_itlbmiss_transaction      = 0;
    729     m_cpt_itlb_ll_transaction       = 0;
    730     m_cpt_itlb_sc_transaction       = 0;
    731     m_cpt_dtlbmiss_transaction      = 0;
    732     m_cpt_dtlb_ll_transaction       = 0;
    733     m_cpt_dtlb_sc_transaction       = 0;
    734     m_cpt_dtlb_ll_dirty_transaction = 0;
    735     m_cpt_dtlb_sc_dirty_transaction = 0;
    736 
    737     m_cost_itlbmiss_transaction      = 0;
    738     m_cost_itlb_ll_transaction       = 0;
    739     m_cost_itlb_sc_transaction       = 0;
    740     m_cost_dtlbmiss_transaction      = 0;
    741     m_cost_dtlb_ll_transaction       = 0;
    742     m_cost_dtlb_sc_transaction       = 0;
    743     m_cost_dtlb_ll_dirty_transaction = 0;
    744     m_cost_dtlb_sc_dirty_transaction = 0;
    745 
    746 //    m_cpt_cc_update_data = 0;
    747 //    m_cpt_cc_inval_ins   = 0;
    748 //    m_cpt_cc_inval_data  = 0;
    749     m_cpt_cc_broadcast   = 0;
    750 
    751     m_cost_updt_data_frz  = 0;
    752     m_cost_inval_ins_frz  = 0;
    753     m_cost_inval_data_frz = 0;
    754     m_cost_broadcast_frz  = 0;
    755 
    756     m_cpt_cc_cleanup_data = 0;
    757     m_cpt_cc_cleanup_ins  = 0;
    758 
    759     m_cpt_cleanup_data_not_dirty  = 0;
     732    m_cost_ins_miss_frz = 0;
     733
     734    m_cpt_write_transaction = 0;
     735    m_length_write_transaction = 0;
     736
     737    m_cpt_itlb_read = 0;
     738    m_cpt_itlb_miss = 0;
     739    m_cpt_itlb_write = 0;
     740    m_cost_ins_tlb_miss_frz = 0;
     741
     742    m_cpt_dtlb_read = 0;
     743    m_cpt_dtlb_miss = 0;
     744    m_cpt_dtlb_write = 0;
     745
     746    m_cpt_cleanup_data_not_dirty = 0;
    760747    m_cpt_cleanup_data_dirty_word = 0;
    761748    m_cpt_data_write_miss = 0;
    762749    m_cpt_data_write_on_zombi = 0;
    763750    m_cpt_data_write_on_zombi_ncc = 0;
    764 
    765751}
    766 
    767 
    768752
    769753/////////////////////////
     
    771755/////////////////////////
    772756{
    773     if ( not p_resetn.read() )
     757    if (not p_resetn.read())
    774758    {
    775759        r_iss.reset();
     
    780764        r_dtlb.reset();
    781765
    782         r_dcache_fsm      = DCACHE_IDLE;
    783         r_icache_fsm      = ICACHE_IDLE;
    784         r_vci_cmd_fsm     = CMD_IDLE;
    785         r_vci_rsp_fsm     = RSP_IDLE;
    786         r_cc_receive_fsm  = CC_RECEIVE_IDLE;
    787         r_cc_send_fsm     = CC_SEND_IDLE;
     766        r_dcache_fsm     = DCACHE_IDLE;
     767        r_icache_fsm     = ICACHE_IDLE;
     768        r_vci_cmd_fsm    = CMD_IDLE;
     769        r_vci_rsp_fsm    = RSP_IDLE;
     770        r_cc_receive_fsm = CC_RECEIVE_IDLE;
     771        r_cc_send_fsm    = CC_SEND_IDLE;
    788772
    789773        // reset data physical address extension
     
    794778
    795779        // reset dcache directory extension
    796         for (size_t i=0 ; i< m_dcache_ways*m_dcache_sets ; i++)
     780        for (size_t i = 0; i < m_dcache_ways * m_dcache_sets; i++)
    797781        {
    798782            r_dcache_content_state[i] = LINE_CACHE_DATA_NOT_DIRTY;
    799             r_dcache_dirty_word[i]    = 0;
    800             r_dcache_zombi_ncc[i]     = false;
     783            r_dcache_dirty_word[i] = 0;
     784            r_dcache_zombi_ncc[i] = false;
    801785        }
    802786
     
    838822
    839823        // No request from DCACHE FSM to CC_SEND FSM
    840         r_dcache_cc_send_req       = false;
     824        r_dcache_cc_send_req        = false;
     825        r_dcache_cleanup_victim_req = false;
     826
    841827        r_dcache_clack_req         = false;
    842828
     
    867853        m_debug_activated          = false;
    868854
    869         // SPECIAL REGISTERS ODCCP
     855        // RWT
    870856        r_dcache_cc_cleanup_updt_data = false;
    871857        r_dcache_cc_cleanup_line_ncc  = false;
    872         r_dcache_miss_victim_no_coherence = false;
    873         r_dcache_line_no_coherence = false;
    874858        r_cc_send_cpt_word = 0;
    875859        r_dcache_miss_data_cpt = 0;
    876860        r_dcache_miss_data_addr = 0;
    877861
    878         r_dcache_cleanup_victim_req = false;
    879862        r_dcache_cleanup_victim_line_ncc = false;
    880863        r_dcache_cleanup_victim_updt_data = false;
     
    894877        m_cpt_stop_simulation   = 0;
    895878
    896         m_cpt_data_miss         = 0;
     879        m_cpt_data_read         = 0;
     880
     881        m_cpt_dcache_miss       = 0;
    897882        m_cpt_data_write        = 0;
    898883        m_cpt_data_sc           = 0;
     
    900885        m_cpt_data_cleanup      = 0;
    901886        m_cpt_cleanup_data_not_dirty = 0;
    902         m_cpt_ins_miss          = 0;
     887        m_cpt_icache_miss       = 0;
    903888        m_cpt_unc_read          = 0;
    904889        m_cpt_write_cached      = 0;
     
    910895        m_cost_ins_miss_frz     = 0;
    911896
     897        m_cpt_dunc_transaction  = 0;
     898        m_cpt_ll_transaction    = 0;
     899
    912900        m_cpt_imiss_transaction = 0;
    913901        m_cpt_dmiss_transaction = 0;
    914902        m_cpt_unc_transaction   = 0;
    915903        m_cpt_write_transaction = 0;
    916         m_cpt_icache_unc_transaction = 0;
    917904
    918905        m_cost_imiss_transaction      = 0;
     
    920907        m_cost_unc_transaction        = 0;
    921908        m_cost_write_transaction      = 0;
    922         m_cost_icache_unc_transaction = 0;
    923909        m_length_write_transaction    = 0;
    924910
    925         m_cpt_ins_tlb_read       = 0;
    926         m_cpt_ins_tlb_miss       = 0;
    927         m_cpt_ins_tlb_update_acc = 0;
    928 
    929         m_cpt_data_tlb_read         = 0;
    930         m_cpt_data_tlb_miss         = 0;
    931         m_cpt_data_tlb_update_acc   = 0;
     911        m_cpt_itlb_read  = 0;
     912        m_cpt_itlb_miss  = 0;
     913        m_cpt_itlb_write = 0;
     914
     915        m_cpt_dtlb_read  = 0;
     916        m_cpt_dtlb_miss  = 0;
     917        m_cpt_dtlb_write = 0;
     918
     919        m_cpt_tlb_occup_dcache      = 0;
    932920        m_cpt_data_tlb_update_dirty = 0;
    933921        m_cpt_ins_tlb_hit_dcache    = 0;
    934922        m_cpt_data_tlb_hit_dcache   = 0;
    935         m_cpt_ins_tlb_occup_cache   = 0;
    936         m_cpt_data_tlb_occup_cache  = 0;
    937923
    938924        m_cost_ins_tlb_miss_frz          = 0;
     
    941927        m_cost_data_tlb_update_acc_frz   = 0;
    942928        m_cost_data_tlb_update_dirty_frz = 0;
    943         m_cost_ins_tlb_occup_cache_frz   = 0;
    944         m_cost_data_tlb_occup_cache_frz  = 0;
    945 
    946         m_cpt_ins_tlb_inval       = 0;
    947         m_cpt_data_tlb_inval      = 0;
    948         m_cost_ins_tlb_inval_frz  = 0;
    949         m_cost_data_tlb_inval_frz = 0;
     929
     930        m_cpt_cc_update_dcache = 0;
     931        m_cpt_cc_inval_icache  = 0;
     932        m_cpt_cc_inval_dcache  = 0;
    950933
    951934        m_cpt_cc_broadcast   = 0;
     
    966949
    967950        m_cpt_itlbmiss_transaction      = 0;
    968         m_cpt_itlb_ll_transaction       = 0;
    969         m_cpt_itlb_sc_transaction       = 0;
    970951        m_cpt_dtlbmiss_transaction      = 0;
    971         m_cpt_dtlb_ll_transaction       = 0;
    972         m_cpt_dtlb_sc_transaction       = 0;
    973         m_cpt_dtlb_ll_dirty_transaction = 0;
    974         m_cpt_dtlb_sc_dirty_transaction = 0;
    975952
    976953        m_cost_itlbmiss_transaction      = 0;
    977         m_cost_itlb_ll_transaction       = 0;
    978         m_cost_itlb_sc_transaction       = 0;
    979954        m_cost_dtlbmiss_transaction      = 0;
    980         m_cost_dtlb_ll_transaction       = 0;
    981         m_cost_dtlb_sc_transaction       = 0;
    982         m_cost_dtlb_ll_dirty_transaction = 0;
    983         m_cost_dtlb_sc_dirty_transaction = 0;
    984 /*
    985         m_cpt_dcache_frz_cycles = 0;
    986         m_cpt_read              = 0;
    987         m_cpt_write             = 0;
    988         m_cpt_cc_update_data = 0;
    989         m_cpt_cc_inval_ins   = 0;
    990         m_cpt_cc_inval_data  = 0;
    991 */
    992 
    993         for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_icache      [i]   = 0;
    994         for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_dcache      [i]   = 0;
    995         for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_cmd         [i]   = 0;
    996         for (uint32_t i=0; i<32 ; ++i) m_cpt_fsm_rsp         [i]   = 0;
     955
     956        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_icache[i] = 0;
     957        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_dcache[i] = 0;
     958        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_cmd[i] = 0;
     959        for (uint32_t i = 0; i < 32; ++i) m_cpt_fsm_rsp[i] = 0;
    997960
    998961        // init the llsc reservation buffer
     
    1004967
    1005968    // Response FIFOs default values
    1006     bool       vci_rsp_fifo_icache_get   = false;
    1007     bool       vci_rsp_fifo_icache_put   = false;
    1008     uint32_t   vci_rsp_fifo_icache_data  = 0;
    1009 
    1010     bool       vci_rsp_fifo_dcache_get   = false;
    1011     bool       vci_rsp_fifo_dcache_put   = false;
    1012     uint32_t   vci_rsp_fifo_dcache_data  = 0;
    1013     bool       vci_rsp_fifo_rpktid_get   = false;
    1014     bool       vci_rsp_fifo_rpktid_put   = false;
    1015     bool       vci_rsp_fifo_rpktid       = false;
     969    bool     vci_rsp_fifo_icache_get  = false;
     970    bool     vci_rsp_fifo_icache_put  = false;
     971    uint32_t vci_rsp_fifo_icache_data = 0;
     972
     973    bool     vci_rsp_fifo_dcache_get  = false;
     974    bool     vci_rsp_fifo_dcache_put  = false;
     975    uint32_t vci_rsp_fifo_dcache_data = 0;
     976
     977    bool     vci_rsp_fifo_rpktid_get  = false;
     978    bool     vci_rsp_fifo_rpktid_put  = false;
     979    bool     vci_rsp_fifo_rpktid      = false;
    1016980
    1017981    // FIFO for cleanup data updt
    1018     bool       cleanup_data_updt_fifo_dcache_get   = false;
    1019     bool       cleanup_data_updt_fifo_dcache_put   = false;
    1020     uint32_t   cleanup_data_updt_fifo_dcache_data = 0;
     982    bool     cleanup_data_updt_fifo_dcache_get  = false;
     983    bool     cleanup_data_updt_fifo_dcache_put  = false;
     984    uint32_t cleanup_data_updt_fifo_dcache_data = 0;
    1021985
    1022986    // updt fifo
    1023     bool       cc_receive_updt_fifo_get  = false;
    1024     bool       cc_receive_updt_fifo_put  = false;
    1025     uint32_t   cc_receive_updt_fifo_be   = 0;
    1026     uint32_t   cc_receive_updt_fifo_data = 0;
    1027     bool       cc_receive_updt_fifo_eop  = false;
     987    bool     cc_receive_updt_fifo_get  = false;
     988    bool     cc_receive_updt_fifo_put  = false;
     989    uint32_t cc_receive_updt_fifo_be   = 0;
     990    uint32_t cc_receive_updt_fifo_data = 0;
     991    bool     cc_receive_updt_fifo_eop  = false;
    1028992
    1029993#ifdef INSTRUMENTATION
     
    10991063
    11001064    // default value for m_irsp
    1101     m_irsp.valid       = false;
    1102     m_irsp.error       = false;
     1065    m_irsp.valid = false;
     1066    m_irsp.error = false;
    11031067    m_irsp.instruction = 0;
    11041068
    1105     switch( r_icache_fsm.read() )
     1069    switch (r_icache_fsm.read())
    11061070    {
    11071071    /////////////////
     
    11151079    {
    11161080        // coherence clack interrupt
    1117         if ( r_icache_clack_req.read() )
     1081        if (r_icache_clack_req.read())
    11181082        {
    11191083            r_icache_fsm = ICACHE_CC_CHECK;
     
    11231087
    11241088        // coherence interrupt
    1125         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
     1089        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    11261090        {
    11271091            r_icache_fsm = ICACHE_CC_CHECK;
     
    11331097        // These request are not executed in this IDLE state (except XTN_INST_PADDR_EXT),
    11341098        // because they require access to icache or itlb, that are already accessed
    1135         if ( r_dcache_xtn_req.read() )
    1136         {
    1137             if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_PTPR )
    1138             {
    1139                 r_icache_fsm         = ICACHE_XTN_TLB_FLUSH;
    1140             }
    1141             else if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_ICACHE_FLUSH)
     1099        if (r_dcache_xtn_req.read())
     1100        {
     1101            if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_PTPR)
     1102            {
     1103                r_icache_fsm = ICACHE_XTN_TLB_FLUSH;
     1104            }
     1105            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_ICACHE_FLUSH)
    11421106            {
    11431107                r_icache_flush_count = 0;
    1144                 r_icache_fsm         = ICACHE_XTN_CACHE_FLUSH;
    1145             }
    1146             else if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_ITLB_INVAL)
    1147             {
    1148                 r_icache_fsm         = ICACHE_XTN_TLB_INVAL;
    1149             }
    1150             else if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_ICACHE_INVAL)
    1151             {
    1152                 r_icache_fsm         = ICACHE_XTN_CACHE_INVAL_VA;
    1153             }
    1154             else if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_MMU_ICACHE_PA_INV)
     1108                r_icache_fsm = ICACHE_XTN_CACHE_FLUSH;
     1109            }
     1110            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_ITLB_INVAL)
     1111            {
     1112                r_icache_fsm = ICACHE_XTN_TLB_INVAL;
     1113            }
     1114            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_ICACHE_INVAL)
     1115            {
     1116                r_icache_fsm = ICACHE_XTN_CACHE_INVAL_VA;
     1117            }
     1118            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_MMU_ICACHE_PA_INV)
    11551119            {
    11561120                if (sizeof(paddr_t) <= 32)
     
    11581122                    assert(r_mmu_word_hi.read() == 0 &&
    11591123                    "illegal XTN request in ICACHE: high bits should be 0 for 32bit paddr");
    1160                     r_icache_vci_paddr = (paddr_t)r_mmu_word_lo.read();
     1124                    r_icache_vci_paddr = (paddr_t) r_mmu_word_lo.read();
    11611125                }
    11621126                else
    11631127                {
    1164                     r_icache_vci_paddr = (paddr_t)r_mmu_word_hi.read() << 32 |
    1165                                          (paddr_t)r_mmu_word_lo.read();
     1128                    r_icache_vci_paddr = (paddr_t) r_mmu_word_hi.read() << 32 |
     1129                                         (paddr_t) r_mmu_word_lo.read();
    11661130                }
    11671131                r_icache_fsm = ICACHE_XTN_CACHE_INVAL_PA;
    11681132            }
    1169             else if ( (int)r_dcache_xtn_opcode.read() == (int)iss_t::XTN_INST_PADDR_EXT)
     1133            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_INST_PADDR_EXT)
    11701134            {
    11711135                r_icache_paddr_ext = r_dcache_save_wdata.read();
     
    11741138            else
    11751139            {
    1176                assert( false and
     1140               assert(false and
    11771141               "undefined XTN request received by ICACHE FSM");
    11781142            }
     
    11811145
    11821146        // processor request
    1183         if ( m_ireq.valid )
    1184         {
    1185             bool        cacheable;
    1186             paddr_t     paddr;
    1187             bool        tlb_hit = false;
    1188             pte_info_t  tlb_flags;
    1189             size_t      tlb_way;
    1190             size_t      tlb_set;
    1191             paddr_t     tlb_nline;
    1192             uint32_t    cache_inst = 0;
    1193             size_t      cache_way;
    1194             size_t      cache_set;
    1195             size_t      cache_word;
    1196             int         cache_state = CACHE_SLOT_STATE_EMPTY;
     1147        if (m_ireq.valid)
     1148        {
     1149            bool       cacheable;
     1150            paddr_t    paddr;
     1151            bool       tlb_hit = false;
     1152            pte_info_t tlb_flags;
     1153            size_t     tlb_way;
     1154            size_t     tlb_set;
     1155            paddr_t    tlb_nline;
     1156            uint32_t   cache_inst = 0;
     1157            size_t     cache_way;
     1158            size_t     cache_set;
     1159            size_t     cache_word;
     1160            int        cache_state = CACHE_SLOT_STATE_EMPTY;
    11971161
    11981162            // We register processor request
     
    12011165
    12021166            // sytematic itlb access (if activated)
    1203             if ( r_mmu_mode.read() & INS_TLB_MASK )
     1167            if (r_mmu_mode.read() & INS_TLB_MASK)
    12041168            {
    12051169
    12061170#ifdef INSTRUMENTATION
    1207 m_cpt_ins_tlb_read++;
    1208 #endif
    1209                 tlb_hit = r_itlb.translate( m_ireq.addr,
    1210                                             &paddr,
    1211                                             &tlb_flags,
    1212                                             &tlb_nline, // unused
    1213                                             &tlb_way,   // unused
    1214                                             &tlb_set ); // unused
     1171                m_cpt_itlb_read++;
     1172#endif
     1173                tlb_hit = r_itlb.translate(m_ireq.addr,
     1174                                           &paddr,
     1175                                           &tlb_flags,
     1176                                           &tlb_nline, // unused
     1177                                           &tlb_way,   // unused
     1178                                           &tlb_set); // unused
    12151179            }
    12161180            else if (vci_param::N > 32)
     
    12201184
    12211185            // systematic icache access (if activated)
    1222             if ( r_mmu_mode.read() & INS_CACHE_MASK )
     1186            if (r_mmu_mode.read() & INS_CACHE_MASK)
    12231187            {
    12241188
    12251189
    12261190#ifdef INSTRUMENTATION
    1227 m_cpt_icache_data_read++;
    1228 m_cpt_icache_dir_read++;
    1229 #endif
    1230                 r_icache.read( paddr,
    1231                                &cache_inst,
    1232                                &cache_way,
    1233                                &cache_set,
    1234                                &cache_word,
    1235                                &cache_state );
     1191                m_cpt_icache_data_read++;
     1192                m_cpt_icache_dir_read++;
     1193#endif
     1194                r_icache.read(paddr,
     1195                              &cache_inst,
     1196                              &cache_way,
     1197                              &cache_set,
     1198                              &cache_word,
     1199                              &cache_state);
    12361200            }
    12371201
     
    12421206            //   and there is no access rights checking
    12431207
    1244             if ( not (r_mmu_mode.read() & INS_TLB_MASK) )  // tlb not activated:
     1208            if (not (r_mmu_mode.read() & INS_TLB_MASK)) // tlb not activated:
    12451209            {
    12461210                // cacheability
    1247                 if ( not (r_mmu_mode.read() & INS_CACHE_MASK) ) cacheable = false;
    1248                 else     cacheable = m_cacheability_table[(uint64_t)m_ireq.addr];
    1249             }
    1250             else                          // itlb activated
    1251             {
    1252                 if ( tlb_hit ) // ITLB hit
     1211                if   (not (r_mmu_mode.read() & INS_CACHE_MASK)) cacheable = false;
     1212                else cacheable = m_cacheability_table[(uint64_t) m_ireq.addr];
     1213            }
     1214            else // itlb activated
     1215            {
     1216                if (tlb_hit) // ITLB hit
    12531217                {
    12541218                    // cacheability
    1255                     if ( not (r_mmu_mode.read() & INS_CACHE_MASK) ) cacheable = false;
    1256                     else  cacheable = tlb_flags.c;
     1219                    if   (not (r_mmu_mode.read() & INS_CACHE_MASK)) cacheable = false;
     1220                    else cacheable = tlb_flags.c;
    12571221
    12581222                    // access rights checking
    1259                     if ( not tlb_flags.u && (m_ireq.mode == iss_t::MODE_USER) )
     1223                    if (not tlb_flags.u && (m_ireq.mode == iss_t::MODE_USER))
    12601224                    {
    1261                         r_mmu_ietr          = MMU_READ_PRIVILEGE_VIOLATION;
    1262                         r_mmu_ibvar         = m_ireq.addr;
    1263                         m_irsp.valid        = true;
    1264                         m_irsp.error        = true;
    1265                         m_irsp.instruction  = 0;
     1225
     1226#if DEBUG_ICACHE
     1227                        if (m_debug_activated)
     1228                            std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Privilege Violation"
     1229                                << " : PADDR = " << std::hex << paddr << std::endl;
     1230#endif
     1231                        r_mmu_ietr         = MMU_READ_PRIVILEGE_VIOLATION;
     1232                        r_mmu_ibvar        = m_ireq.addr;
     1233                        m_irsp.valid       = true;
     1234                        m_irsp.error       = true;
     1235                        m_irsp.instruction = 0;
    12661236                        break;
    12671237                    }
    1268                     else if ( not tlb_flags.x )
     1238                    else if (not tlb_flags.x)
    12691239                    {
    1270                         r_mmu_ietr          = MMU_READ_EXEC_VIOLATION;
    1271                         r_mmu_ibvar         = m_ireq.addr;
    1272                         m_irsp.valid        = true;
    1273                         m_irsp.error        = true;
    1274                         m_irsp.instruction  = 0;
     1240
     1241#if DEBUG_ICACHE
     1242                        if (m_debug_activated)
     1243                        {
     1244                            std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Executable Violation"
     1245                                << " : PADDR = " << std::hex << paddr << std::endl;
     1246                        }
     1247#endif
     1248                        r_mmu_ietr         = MMU_READ_EXEC_VIOLATION;
     1249                        r_mmu_ibvar        = m_ireq.addr;
     1250                        m_irsp.valid       = true;
     1251                        m_irsp.error       = true;
     1252                        m_irsp.instruction = 0;
    12751253                        break;
    12761254                    }
    12771255                }
    1278                 else           // ITLB miss
     1256                else // ITLB miss
    12791257                {
    12801258
    12811259#ifdef INSTRUMENTATION
    1282 m_cpt_ins_tlb_miss++;
     1260                    m_cpt_itlb_miss++;
    12831261#endif
    12841262                    r_icache_fsm          = ICACHE_TLB_WAIT;
     
    12891267
    12901268            // physical address registration
    1291             r_icache_vci_paddr   = paddr;
     1269            r_icache_vci_paddr = paddr;
    12921270
    12931271            // Finally, we send the response to processor, and compute next state
    1294             if ( cacheable )
    1295             {
    1296 
    1297                 if (cache_state == CACHE_SLOT_STATE_EMPTY)      // cache miss
     1272            if (cacheable)
     1273            {
     1274                if (cache_state == CACHE_SLOT_STATE_EMPTY) // cache miss
    12981275                {
    12991276
    13001277#ifdef INSTRUMENTATION
    1301 m_cpt_ins_miss++;
     1278                    m_cpt_icache_miss++;
    13021279#endif
    13031280                    // we request a VCI transaction
    1304                     r_icache_fsm      = ICACHE_MISS_SELECT;
     1281                    r_icache_fsm = ICACHE_MISS_SELECT;
    13051282#if DEBUG_ICACHE
    1306 if ( m_debug_activated )
    1307 std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache"
    1308           << " : PADDR = " << std::hex << paddr << std::endl;
     1283                    if (m_debug_activated)
     1284                    {
     1285                        std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache"
     1286                            << " : PADDR = " << std::hex << paddr << std::endl;
     1287                    }
    13091288#endif
    13101289                   r_icache_miss_req = true;
    13111290                }
    1312                 else if (cache_state == CACHE_SLOT_STATE_ZOMBI )    // pending cleanup
     1291                else if (cache_state == CACHE_SLOT_STATE_ZOMBI ) // pending cleanup
    13131292                {
    13141293                    // stalled until cleanup is acknowledged
    1315                     r_icache_fsm       = ICACHE_IDLE;
    1316                 }
    1317                 else                                       // cache hit
     1294                    r_icache_fsm = ICACHE_IDLE;
     1295                }
     1296                else // cache hit
    13181297                {
    13191298
    13201299#ifdef INSTRUMENTATION
    1321 m_cpt_ins_read++;
     1300                    m_cpt_ins_read++;
    13221301#endif
    13231302                    // return instruction to processor
     
    13261305                    r_icache_fsm       = ICACHE_IDLE;
    13271306#if DEBUG_ICACHE
    1328 if ( m_debug_activated )
    1329 std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache"
    1330           << " : PADDR = " << std::hex << paddr
    1331           << " / INST  = " << cache_inst << std::dec << std::endl;
    1332 #endif
    1333                 }
    1334             }
    1335             else               // non cacheable read
    1336             {
    1337                 r_icache_unc_req  = true;
    1338                 r_icache_fsm      = ICACHE_UNC_WAIT;
     1307                    if (m_debug_activated)
     1308                    {
     1309                        std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache"
     1310                            << " : PADDR = " << std::hex << paddr
     1311                            << " / INST  = " << cache_inst << std::dec << std::endl;
     1312                    }
     1313#endif
     1314                }
     1315            }
     1316            else // non cacheable read
     1317            {
     1318                r_icache_unc_req = true;
     1319                r_icache_fsm     = ICACHE_UNC_WAIT;
    13391320
    13401321#if DEBUG_ICACHE
    1341 if ( m_debug_activated )
    1342 {
    1343     std::cout << "  <PROC " << name()
    1344               << " ICACHE_IDLE> READ UNCACHEABLE in icache"
    1345               << " : PADDR = " << std::hex << paddr << std::endl;
    1346 }
     1322                if (m_debug_activated)
     1323                {
     1324                    std::cout << "  <PROC " << name()
     1325                        << " ICACHE_IDLE> READ UNCACHEABLE in icache"
     1326                        << " : PADDR = " << std::hex << paddr << std::endl;
     1327                }
    13471328#endif
    13481329            }
     
    13591340    {
    13601341        // coherence clack interrupt
    1361         if ( r_icache_clack_req.read() )
     1342        if (r_icache_clack_req.read())
    13621343        {
    13631344            r_icache_fsm = ICACHE_CC_CHECK;
     
    13671348
    13681349        // coherence interrupt
    1369         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
     1350        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    13701351        {
    13711352            r_icache_fsm = ICACHE_CC_CHECK;
     
    13741355        }
    13751356
    1376         if ( m_ireq.valid ) m_cost_ins_tlb_miss_frz++;
     1357        if (m_ireq.valid) m_cost_ins_tlb_miss_frz++;
    13771358
    13781359        // DCACHE FSM signals response by reseting the request flip-flop
    1379         if ( not r_icache_tlb_miss_req.read() )
    1380         {
    1381             if ( r_icache_tlb_rsp_error.read() ) // error reported : tlb not updated
     1360        if (not r_icache_tlb_miss_req.read())
     1361        {
     1362            if (r_icache_tlb_rsp_error.read()) // error reported : tlb not updated
    13821363            {
    13831364                r_icache_tlb_rsp_error = false;
    1384                 m_irsp.error             = true;
    1385                 m_irsp.valid             = true;
    1386                 r_icache_fsm             = ICACHE_IDLE;
    1387             }
    1388             else                // tlb updated : return to IDLE state
     1365                m_irsp.error = true;
     1366                m_irsp.valid = true;
     1367                r_icache_fsm = ICACHE_IDLE;
     1368            }
     1369            else // tlb updated : return to IDLE state
    13891370            {
    13901371                r_icache_fsm  = ICACHE_IDLE;
     
    13941375    }
    13951376    //////////////////////////
    1396     case ICACHE_XTN_TLB_FLUSH:      // invalidate in one cycle all non global TLB entries
     1377    case ICACHE_XTN_TLB_FLUSH:  // invalidate in one cycle all non global TLB entries
    13971378    {
    13981379        r_itlb.flush();
    1399         r_dcache_xtn_req     = false;
    1400         r_icache_fsm         = ICACHE_IDLE;
     1380        r_dcache_xtn_req = false;
     1381        r_icache_fsm     = ICACHE_IDLE;
    14011382        break;
    14021383    }
     
    14111392    {
    14121393        // coherence clack interrupt
    1413         if ( r_icache_clack_req.read() )
     1394        if (r_icache_clack_req.read())
    14141395        {
    14151396            r_icache_fsm = ICACHE_CC_CHECK;
     
    14191400
    14201401        // coherence request (from CC_RECEIVE FSM)
    1421         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
     1402        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    14221403        {
    14231404            r_icache_fsm = ICACHE_CC_CHECK;
     
    14261407        }
    14271408
    1428         if ( not r_icache_cc_send_req.read() ) // blocked until previous cc_send request is sent
    1429         {
    1430             int       state;
    1431             paddr_t   tag;
    1432             size_t    way = r_icache_flush_count.read()/m_icache_sets;
    1433             size_t    set = r_icache_flush_count.read()%m_icache_sets;
     1409        if (not r_icache_cc_send_req.read()) // blocked until previous cc_send request is sent
     1410        {
     1411            int state;
     1412            paddr_t tag;
     1413            size_t way = r_icache_flush_count.read() / m_icache_sets;
     1414            size_t set = r_icache_flush_count.read() % m_icache_sets;
    14341415
    14351416#ifdef INSTRUMENTATION
    1436 m_cpt_icache_dir_read++;
    1437 #endif
    1438             r_icache.read_dir( way,
    1439                                set,
    1440                                &tag,
    1441                                &state );
    1442 
    1443             if ( state == CACHE_SLOT_STATE_VALID_CC )    // inval required
     1417            m_cpt_icache_dir_read++;
     1418#endif
     1419            r_icache.read_dir(way,
     1420                              set,
     1421                              &tag,
     1422                              &state);
     1423
     1424            if (state == CACHE_SLOT_STATE_VALID_CC)    // inval required
    14441425            {
    14451426                // request cleanup
     
    14501431
    14511432                // goes to ICACHE_XTN_CACHE_FLUSH_GO to make inval
    1452                 r_icache_miss_way     = way;
    1453                 r_icache_miss_set     = set;
    1454                 r_icache_fsm          = ICACHE_XTN_CACHE_FLUSH_GO;
    1455             }
    1456             else if ( r_icache_flush_count.read() ==
    1457                       (m_icache_sets*m_icache_ways - 1) )  // last slot
     1433                r_icache_miss_way = way;
     1434                r_icache_miss_set = set;
     1435                r_icache_fsm      = ICACHE_XTN_CACHE_FLUSH_GO;
     1436            }
     1437            else if (r_icache_flush_count.read() ==
     1438                      (m_icache_sets*m_icache_ways - 1))  // last slot
    14581439            {
    14591440                r_dcache_xtn_req = false;
    1460                 m_drsp.valid     = true;
    1461                 r_icache_fsm     = ICACHE_IDLE;
     1441                m_drsp.valid = true;
     1442                r_icache_fsm = ICACHE_IDLE;
    14621443            }
    14631444
    14641445            // saturation counter, to have the same last slot condition
    14651446            // in ICACHE_XTN_CACHE_FLUSH and ICACHE_XTN_CACHE_FLUSH_GO states
    1466             if ( r_icache_flush_count.read() < (m_icache_sets*m_icache_ways - 1) )
     1447            if (r_icache_flush_count.read() < (m_icache_sets * m_icache_ways - 1))
    14671448            {
    14681449                r_icache_flush_count = r_icache_flush_count.read() + 1;
     
    14721453    }
    14731454    ///////////////////////////////
    1474     case ICACHE_XTN_CACHE_FLUSH_GO:     // Switch slot state to ZOMBI for an XTN flush
    1475     {
    1476         size_t  way = r_icache_miss_way.read();
    1477         size_t  set = r_icache_miss_set.read();
     1455    case ICACHE_XTN_CACHE_FLUSH_GO:   // Switch slot state to ZOMBI for an XTN flush
     1456    {
     1457        size_t way = r_icache_miss_way.read();
     1458        size_t set = r_icache_miss_set.read();
    14781459
    14791460#ifdef INSTRUMENTATION
    1480 m_cpt_icache_dir_write++;
    1481 #endif
    1482 
    1483         r_icache.write_dir( way,
    1484                             set,
    1485                             CACHE_SLOT_STATE_ZOMBI );
    1486 
    1487         if ( r_icache_flush_count.read() ==
    1488                       (m_icache_sets*m_icache_ways - 1) )  // last slot
     1461        m_cpt_icache_dir_write++;
     1462#endif
     1463
     1464        r_icache.write_dir(way,
     1465                           set,
     1466                           CACHE_SLOT_STATE_ZOMBI);
     1467
     1468        if (r_icache_flush_count.read() ==
     1469                      (m_icache_sets*m_icache_ways - 1))  // last slot
    14891470        {
    14901471            r_dcache_xtn_req = false;
    1491             m_drsp.valid     = true;
    1492             r_icache_fsm     = ICACHE_IDLE;
     1472            m_drsp.valid = true;
     1473            r_icache_fsm = ICACHE_IDLE;
    14931474        }
    14941475        else
    14951476        {
    1496             r_icache_fsm         = ICACHE_XTN_CACHE_FLUSH;
     1477            r_icache_fsm = ICACHE_XTN_CACHE_FLUSH;
    14971478        }
    14981479        break;
     
    15001481
    15011482    //////////////////////////
    1502     case ICACHE_XTN_TLB_INVAL:      // invalidate one TLB entry selected by the virtual address
    1503                                     // stored in the r_dcache_save_wdata register
     1483    case ICACHE_XTN_TLB_INVAL: // invalidate one TLB entry selected by the virtual address
     1484                               // stored in the r_dcache_save_wdata register
    15041485    {
    15051486        r_itlb.inval(r_dcache_save_wdata.read());
    1506         r_dcache_xtn_req     = false;
    1507         r_icache_fsm         = ICACHE_IDLE;
     1487        r_dcache_xtn_req = false;
     1488        r_icache_fsm     = ICACHE_IDLE;
    15081489        break;
    15091490    }
     
    15181499
    15191500        // read physical address in TLB when MMU activated
    1520         if ( r_mmu_mode.read() & INS_TLB_MASK )    // itlb activated
     1501        if (r_mmu_mode.read() & INS_TLB_MASK) // itlb activated
    15211502        {
    15221503
    15231504#ifdef INSTRUMENTATION
    1524 m_cpt_ins_tlb_read++;
    1525 #endif
    1526             hit = r_itlb.translate(r_dcache_save_wdata.read(),
    1527                                    &paddr);
    1528         }
    1529         else                        // itlb not activated
    1530         {
    1531             paddr   = (paddr_t)r_dcache_save_wdata.read();
    1532             hit     = true;
    1533         }
    1534 
    1535         if ( hit )      // continue the selective inval process
    1536         {
    1537             r_icache_vci_paddr    = paddr;
    1538             r_icache_fsm          = ICACHE_XTN_CACHE_INVAL_PA;
    1539         }
    1540         else            // miss : send a request to DCACHE FSM
     1505            m_cpt_itlb_read++;
     1506#endif
     1507            hit = r_itlb.translate(r_dcache_save_wdata.read(), &paddr);
     1508        }
     1509        else // itlb not activated
     1510        {
     1511            paddr = (paddr_t) r_dcache_save_wdata.read();
     1512            hit   = true;
     1513        }
     1514
     1515        if (hit) // continue the selective inval process
     1516        {
     1517            r_icache_vci_paddr = paddr;
     1518            r_icache_fsm       = ICACHE_XTN_CACHE_INVAL_PA;
     1519        }
     1520        else // miss : send a request to DCACHE FSM
    15411521        {
    15421522
    15431523#ifdef INSTRUMENTATION
    1544 m_cpt_ins_tlb_miss++;
     1524            m_cpt_itlb_miss++;
    15451525#endif
    15461526            r_icache_tlb_miss_req = true;
     
    15551535                                    // with address stored in r_icache_vci_paddr register.
    15561536    {
    1557         int         state;
    1558         size_t      way;
    1559         size_t      set;
    1560         size_t      word;
     1537        int    state;
     1538        size_t way;
     1539        size_t set;
     1540        size_t word;
    15611541
    15621542#ifdef INSTRUMENTATION
    1563 m_cpt_icache_dir_read++;
     1543        m_cpt_icache_dir_read++;
    15641544#endif
    15651545        r_icache.read_dir(r_icache_vci_paddr.read(),
     
    15691549                          &word);
    15701550
    1571         if ( state == CACHE_SLOT_STATE_VALID_CC )  // inval to be done
     1551        if (state == CACHE_SLOT_STATE_VALID_CC) // inval to be done
    15721552        {
    15731553            r_icache_miss_way = way;
     
    15751555            r_icache_fsm      = ICACHE_XTN_CACHE_INVAL_GO;
    15761556        }
    1577         else        // miss : acknowlege the XTN request and return
     1557        else // miss : acknowlege the XTN request and return
    15781558        {
    15791559            r_dcache_xtn_req = false;
     
    15851565    case ICACHE_XTN_CACHE_INVAL_GO:  // Switch slot to ZOMBI state for an XTN inval
    15861566    {
    1587         if ( not r_icache_cc_send_req.read() )  // blocked until previous cc_send request not sent
     1567        if (not r_icache_cc_send_req.read())  // blocked until previous cc_send request not sent
    15881568        {
    15891569
    15901570#ifdef INSTRUMENTATION
    1591 m_cpt_icache_dir_write++;
    1592 #endif
    1593             r_icache.write_dir( r_icache_miss_way.read(),
    1594                                 r_icache_miss_set.read(),
    1595                                 CACHE_SLOT_STATE_ZOMBI );
     1571            m_cpt_icache_dir_write++;
     1572#endif
     1573            r_icache.write_dir(r_icache_miss_way.read(),
     1574                               r_icache_miss_set.read(),
     1575                               CACHE_SLOT_STATE_ZOMBI);
    15961576
    15971577            // request cleanup
    15981578            r_icache_cc_send_req   = true;
    1599             r_icache_cc_send_nline = r_icache_vci_paddr.read() / (m_icache_words<<2);
     1579            r_icache_cc_send_nline = r_icache_vci_paddr.read() / (m_icache_words << 2);
    16001580            r_icache_cc_send_way   = r_icache_miss_way.read();
    16011581            r_icache_cc_send_type  = CC_TYPE_CLEANUP;
    16021582
    16031583            // acknowledge the XTN request and return
    1604             r_dcache_xtn_req      = false;
    1605             r_icache_fsm          = ICACHE_IDLE;
     1584            r_dcache_xtn_req = false;
     1585            r_icache_fsm     = ICACHE_IDLE;
    16061586        }
    16071587        break;
     
    16091589    ////////////////////////
    16101590    case ICACHE_MISS_SELECT:       // Try to select a slot in associative set,
    1611                                    // if previous cleanup has been sent.
    16121591                                   // Waiting in this state if no slot available.
    1613                                    // Set the r_icache_cleanup_req flip-flop
    1614                                    // and the r_icache_miss_clack flip-flop,
     1592                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
     1593                                   // we send the cleanup request in this state.
     1594                                   // If not, a r_icache_cleanup_victim_req flip-flop is
     1595                                   // utilized for saving this cleanup request, and it will be sent later
     1596                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
     1597                                   // The r_icache_miss_clack flip-flop is set
    16151598                                   // when a cleanup is required
    16161599    {
     
    16181601
    16191602        // coherence clack interrupt
    1620         if ( r_icache_clack_req.read() )
     1603        if (r_icache_clack_req.read())
    16211604        {
    16221605            r_icache_fsm = ICACHE_CC_CHECK;
     
    16261609
    16271610        // coherence interrupt
    1628         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
     1611        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    16291612        {
    16301613            r_icache_fsm = ICACHE_CC_CHECK;
     
    16341617
    16351618
    1636         bool        found;
    1637         bool        cleanup;
    1638         size_t      way;
    1639         size_t      set;
    1640         paddr_t     victim;
     1619        bool found;
     1620        bool cleanup;
     1621        size_t way;
     1622        size_t set;
     1623        paddr_t victim;
    16411624
    16421625#ifdef INSTRUMENTATION
    1643 m_cpt_icache_dir_read++;
     1626        m_cpt_icache_dir_read++;
    16441627#endif
    16451628        r_icache.read_select(r_icache_vci_paddr.read(),
     
    16481631                             &set,
    16491632                             &found,
    1650                              &cleanup );
    1651         if ( found )
    1652         {
    1653             r_icache_miss_way     = way;
    1654             r_icache_miss_set     = set;
    1655 
    1656             if ( cleanup )
    1657             {
    1658                 if ( not r_icache_cc_send_req.read() )
    1659                 {
    1660                     r_icache_cc_send_req    = true;
    1661                     r_icache_cc_send_nline  = victim;
    1662                     r_icache_cc_send_way    = way;
    1663                     r_icache_cc_send_type   = CC_TYPE_CLEANUP;
     1633                             &cleanup);
     1634        if (found)
     1635        {
     1636            r_icache_miss_way = way;
     1637            r_icache_miss_set = set;
     1638
     1639            if (cleanup)
     1640            {
     1641                if (not r_icache_cc_send_req.read())
     1642                {
     1643                    r_icache_cc_send_req   = true;
     1644                    r_icache_cc_send_nline = victim;
     1645                    r_icache_cc_send_way   = way;
     1646                    r_icache_cc_send_type  = CC_TYPE_CLEANUP;
    16641647                }
    16651648                else
     
    16691652                }
    16701653
    1671                 r_icache_miss_clack           = true;
    1672                 r_icache_fsm                  = ICACHE_MISS_CLEAN;
     1654                r_icache_miss_clack = true;
     1655                r_icache_fsm        = ICACHE_MISS_CLEAN;
    16731656            }
    16741657            else
    16751658            {
    1676                 r_icache_fsm          = ICACHE_MISS_WAIT;
     1659                r_icache_fsm = ICACHE_MISS_WAIT;
    16771660            }
    16781661
    16791662#if DEBUG_ICACHE
    1680 if ( m_debug_activated )
    1681 {
    1682     std::cout << "  <PROC " << name()
    1683               << " ICACHE_MISS_SELECT> Select a slot:" << std::dec
    1684               << " / WAY = " << way
    1685               << " / SET = " << set;
    1686     if (cleanup) std::cout << " / VICTIM = " << std::hex << victim << std::endl;
    1687     else         std::cout << std::endl;
    1688 }
     1663            if (m_debug_activated)
     1664            {
     1665                std::cout << "  <PROC " << name()
     1666                    << " ICACHE_MISS_SELECT> Select a slot:" << std::dec
     1667                    << " / WAY = " << way
     1668                    << " / SET = " << set;
     1669                if (cleanup) std::cout << " / VICTIM = " << std::hex << victim << std::endl;
     1670                else         std::cout << std::endl;
     1671            }
    16891672#endif
    16901673        }
     
    16921675    }
    16931676    ///////////////////////
    1694     case ICACHE_MISS_CLEAN:          // switch the slot to zombi state
     1677    case ICACHE_MISS_CLEAN:   // switch the slot to zombi state
    16951678    {
    16961679        if (m_ireq.valid) m_cost_ins_miss_frz++;
    16971680
    16981681#ifdef INSTRUMENTATION
    1699 m_cpt_icache_dir_write++;
    1700 #endif
    1701         r_icache.write_dir( r_icache_miss_way.read(),
    1702                             r_icache_miss_set.read(),
    1703                             CACHE_SLOT_STATE_ZOMBI);
     1682        m_cpt_icache_dir_write++;
     1683#endif
     1684        r_icache.write_dir(r_icache_miss_way.read(),
     1685                           r_icache_miss_set.read(),
     1686                           CACHE_SLOT_STATE_ZOMBI);
    17041687#if DEBUG_ICACHE
    1705 if ( m_debug_activated )
    1706 {
    1707     std::cout << "  <PROC " << name()
    1708               << " ICACHE_MISS_CLEAN> Switch to ZOMBI state" << std::dec
    1709               << " / WAY = " << r_icache_miss_way.read()
    1710               << " / SET = " << r_icache_miss_set.read() << std::endl;
    1711 }
     1688        if (m_debug_activated)
     1689        {
     1690            std::cout << "  <PROC " << name()
     1691                << " ICACHE_MISS_CLEAN> Switch to ZOMBI state" << std::dec
     1692                << " / WAY = " << r_icache_miss_way.read()
     1693                << " / SET = " << r_icache_miss_set.read() << std::endl;
     1694        }
    17121695#endif
    17131696
     
    17161699    }
    17171700    //////////////////////
    1718     case ICACHE_MISS_WAIT:    // waiting response from VCI_RSP FSM
     1701    case ICACHE_MISS_WAIT: // waiting response from VCI_RSP FSM
    17191702    {
    17201703        if (m_ireq.valid) m_cost_ins_miss_frz++;
    17211704
    1722         if ( r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read() )
     1705        // send cleanup victim request
     1706        if (r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read())
    17231707        {
    17241708            r_icache_cc_send_req        = true;
     
    17301714
    17311715        // coherence clack interrupt
    1732         if ( r_icache_clack_req.read() )
     1716        if (r_icache_clack_req.read())
    17331717        {
    17341718            r_icache_fsm = ICACHE_CC_CHECK;
     
    17381722
    17391723        // coherence interrupt
    1740         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read() )
     1724        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read())
    17411725        {
    17421726            r_icache_fsm = ICACHE_CC_CHECK;
     
    17451729        }
    17461730
    1747         if ( r_vci_rsp_ins_error.read() ) // bus error
     1731        if (r_vci_rsp_ins_error.read()) // bus error
    17481732        {
    17491733            r_mmu_ietr          = MMU_READ_DATA_ILLEGAL_ACCESS;
     
    17541738            r_icache_fsm        = ICACHE_IDLE;
    17551739        }
    1756         else if ( r_vci_rsp_fifo_icache.rok() ) // response available
     1740        else if (r_vci_rsp_fifo_icache.rok()) // response available
    17571741        {
    17581742            r_icache_miss_word = 0;
     
    17621746    }
    17631747    ///////////////////////////
    1764     case ICACHE_MISS_DATA_UPDT:   // update the cache (one word per cycle)
    1765     {
    1766         if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    1767 
    1768         if ( r_vci_rsp_fifo_icache.rok() ) // response available
     1748    case ICACHE_MISS_DATA_UPDT:  // update the cache (one word per cycle)
     1749    {
     1750        if (m_ireq.valid) m_cost_ins_miss_frz++;
     1751
     1752        if (r_vci_rsp_fifo_icache.rok()) // response available
    17691753        {
    17701754
    17711755#ifdef INSTRUMENTATION
    1772 m_cpt_icache_data_write++;
    1773 #endif
    1774             r_icache.write( r_icache_miss_way.read(),
    1775                             r_icache_miss_set.read(),
    1776                             r_icache_miss_word.read(),
    1777                             r_vci_rsp_fifo_icache.read() );
     1756            m_cpt_icache_data_write++;
     1757#endif
     1758            r_icache.write(r_icache_miss_way.read(),
     1759                           r_icache_miss_set.read(),
     1760                           r_icache_miss_word.read(),
     1761                           r_vci_rsp_fifo_icache.read());
    17781762#if DEBUG_ICACHE
    1779 if ( m_debug_activated )
    1780 {
    1781     std::cout << "  <PROC " << name()
    1782               << " ICACHE_MISS_DATA_UPDT> Write one word:"
    1783               << " WDATA = " << std::hex << r_vci_rsp_fifo_icache.read()
    1784               << " WAY = " << r_icache_miss_way.read()
    1785               << " SET = " << r_icache_miss_set.read()
    1786               << " WORD = " << r_icache_miss_word.read() << std::endl;
    1787 }
     1763            if (m_debug_activated)
     1764            {
     1765                std::cout << "  <PROC " << name()
     1766                    << " ICACHE_MISS_DATA_UPDT> Write one word:"
     1767                    << " WDATA = " << std::hex << r_vci_rsp_fifo_icache.read()
     1768                    << " WAY = " << r_icache_miss_way.read()
     1769                    << " SET = " << r_icache_miss_set.read()
     1770                    << " WORD = " << r_icache_miss_word.read() << std::endl;
     1771            }
    17881772#endif
    17891773            vci_rsp_fifo_icache_get = true;
    17901774            r_icache_miss_word = r_icache_miss_word.read() + 1;
    17911775
    1792             if ( r_icache_miss_word.read() == m_icache_words-1 )  // last word
     1776            if (r_icache_miss_word.read() == m_icache_words - 1) // last word
    17931777            {
    17941778                r_icache_fsm = ICACHE_MISS_DIR_UPDT;
     
    18061790                                //   to ZOMBI state, and send a cleanup request.
    18071791    {
    1808         if ( m_ireq.valid ) m_cost_ins_miss_frz++;
     1792        if (m_ireq.valid) m_cost_ins_miss_frz++;
    18091793
    18101794        // send cleanup victim request
    1811         if ( r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read() )
     1795        if (r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read())
    18121796        {
    18131797            r_icache_cc_send_req        = true;
     
    18191803
    18201804        // coherence clack interrupt
    1821         if ( r_icache_clack_req.read() )
     1805        if (r_icache_clack_req.read())
    18221806        {
    18231807            r_icache_fsm = ICACHE_CC_CHECK;
     
    18271811
    18281812        // coherence interrupt
    1829         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read() )
     1813        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read())
    18301814        {
    18311815            r_icache_fsm = ICACHE_CC_CHECK;
     
    18341818        }
    18351819
    1836         if ( not r_icache_miss_clack.read() ) // waiting cleanup acknowledge for victim line
    1837         {
    1838             if ( r_icache_miss_inval )    // Switch slot to ZOMBI state, and new cleanup
    1839             {
    1840                 if ( not r_icache_cc_send_req.read() )
     1820        if (not r_icache_miss_clack.read()) // waiting cleanup acknowledge for victim line
     1821        {
     1822            if (r_icache_miss_inval) // Switch slot to ZOMBI state, and new cleanup
     1823            {
     1824                if (not r_icache_cc_send_req.read())
    18411825                {
    18421826                    r_icache_miss_inval    = false;
    18431827                    // request cleanup
    18441828                    r_icache_cc_send_req   = true;
    1845                     r_icache_cc_send_nline = r_icache_vci_paddr.read() / (m_icache_words<<2);
     1829                    r_icache_cc_send_nline = r_icache_vci_paddr.read() / (m_icache_words << 2);
    18461830                    r_icache_cc_send_way   = r_icache_miss_way.read();
    18471831                    r_icache_cc_send_type  = CC_TYPE_CLEANUP;
    18481832
    18491833#ifdef INSTRUMENTATION
    1850 m_cpt_icache_dir_write++;
    1851 #endif
    1852                     r_icache.write_dir( r_icache_vci_paddr.read(),
    1853                                         r_icache_miss_way.read(),
    1854                                         r_icache_miss_set.read(),
    1855                                         CACHE_SLOT_STATE_ZOMBI );
     1834                    m_cpt_icache_dir_write++;
     1835#endif
     1836                    r_icache.write_dir(r_icache_vci_paddr.read(),
     1837                                       r_icache_miss_way.read(),
     1838                                       r_icache_miss_set.read(),
     1839                                       CACHE_SLOT_STATE_ZOMBI);
    18561840#if DEBUG_ICACHE
    1857 if ( m_debug_activated )
    1858 {
    1859     std::cout << "  <PROC " << name()
    1860               << " ICACHE_MISS_DIR_UPDT> Switch cache slot to ZOMBI state"
    1861               << " PADDR = " << std::hex << r_icache_vci_paddr.read()
    1862               << " WAY = " << std::dec << r_icache_miss_way.read()
    1863               << " SET = " << r_icache_miss_set.read() << std::endl;
    1864 }
     1841                    if (m_debug_activated)
     1842                    {
     1843                        std::cout << "  <PROC " << name()
     1844                            << " ICACHE_MISS_DIR_UPDT> Switch cache slot to ZOMBI state"
     1845                            << " PADDR = " << std::hex << r_icache_vci_paddr.read()
     1846                            << " WAY = " << std::dec << r_icache_miss_way.read()
     1847                            << " SET = " << r_icache_miss_set.read() << std::endl;
     1848                    }
    18651849#endif
    18661850                }
     
    18681852                    break;
    18691853            }
    1870             else                          // Switch slot to VALID state
     1854            else // Switch slot to VALID state
    18711855            {
    18721856
    18731857#ifdef INSTRUMENTATION
    1874 m_cpt_icache_dir_write++;
    1875 #endif
    1876                 r_icache.write_dir( r_icache_vci_paddr.read(),
    1877                                     r_icache_miss_way.read(),
    1878                                     r_icache_miss_set.read(),
    1879                                     CACHE_SLOT_STATE_VALID_CC );
     1858                m_cpt_icache_dir_write++;
     1859#endif
     1860                r_icache.write_dir(r_icache_vci_paddr.read(),
     1861                                   r_icache_miss_way.read(),
     1862                                   r_icache_miss_set.read(),
     1863                                   CACHE_SLOT_STATE_VALID_CC);
    18801864#if DEBUG_ICACHE
    1881 if ( m_debug_activated )
    1882 {
    1883     std::cout << "  <PROC " << name()
    1884               << " ICACHE_MISS_DIR_UPDT> Switch cache slot to VALID state"
    1885               << " PADDR = " << std::hex << r_icache_vci_paddr.read()
    1886               << " WAY = " << std::dec << r_icache_miss_way.read()
    1887               << " SET = " << r_icache_miss_set.read() << std::endl;
    1888 }
     1865                if (m_debug_activated)
     1866                {
     1867                    std::cout << "  <PROC " << name()
     1868                        << " ICACHE_MISS_DIR_UPDT> Switch cache slot to VALID state"
     1869                        << " PADDR = " << std::hex << r_icache_vci_paddr.read()
     1870                        << " WAY = " << std::dec << r_icache_miss_way.read()
     1871                        << " SET = " << r_icache_miss_set.read() << std::endl;
     1872                }
    18891873#endif
    18901874            }
     
    18951879    }
    18961880    ////////////////////
    1897     case ICACHE_UNC_WAIT:  // waiting a response to an uncacheable read from VCI_RSP FSM
     1881    case ICACHE_UNC_WAIT: // waiting a response to an uncacheable read from VCI_RSP FSM
    18981882    {
    18991883        // coherence clack interrupt
    1900         if ( r_icache_clack_req.read() )
    1901         {
    1902             r_icache_fsm = ICACHE_CC_CHECK;
     1884        if (r_icache_clack_req.read())
     1885        {
     1886            r_icache_fsm      = ICACHE_CC_CHECK;
    19031887            r_icache_fsm_save = r_icache_fsm.read();
    19041888            break;
     
    19061890
    19071891        // coherence interrupt
    1908         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    1909         {
    1910             r_icache_fsm = ICACHE_CC_CHECK;
     1892        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
     1893        {
     1894            r_icache_fsm      = ICACHE_CC_CHECK;
    19111895            r_icache_fsm_save = r_icache_fsm.read();
    19121896            break;
    19131897        }
    19141898
    1915         if ( r_vci_rsp_ins_error.read() ) // bus error
     1899        if (r_vci_rsp_ins_error.read()) // bus error
    19161900        {
    19171901            r_mmu_ietr          = MMU_READ_DATA_ILLEGAL_ACCESS;
     
    19221906            r_icache_fsm        = ICACHE_IDLE;
    19231907        }
    1924         else if (r_vci_rsp_fifo_icache.rok() ) // instruction available
     1908        else if (r_vci_rsp_fifo_icache.rok()) // instruction available
    19251909        {
    19261910            vci_rsp_fifo_icache_get = true;
    19271911            r_icache_fsm            = ICACHE_IDLE;
    1928             if ( m_ireq.valid and
    1929                 (m_ireq.addr == r_icache_vaddr_save.read()) ) // request unmodified
     1912            if (m_ireq.valid and
     1913                (m_ireq.addr == r_icache_vaddr_save.read())) // request unmodified
    19301914            {
    19311915                m_irsp.valid       = true;
     
    19361920    }
    19371921    /////////////////////
    1938     case ICACHE_CC_CHECK:       // This state is the entry point of a sub-fsm
    1939                                 // handling coherence requests.
    1940                                 // if there is a matching pending miss, it is
    1941                                 // signaled in the r_icache_miss_inval flip-flop.
    1942                                 // The return state is defined in r_icache_fsm_save.
    1943     {
    1944         paddr_t  paddr = r_cc_receive_icache_nline.read() * m_icache_words * 4;
    1945         paddr_t  mask  = ~((m_icache_words<<2)-1);
     1922    case ICACHE_CC_CHECK:   // This state is the entry point of a sub-fsm
     1923                            // handling coherence requests.
     1924                            // if there is a matching pending miss, it is
     1925                            // signaled in the r_icache_miss_inval flip-flop.
     1926                            // The return state is defined in r_icache_fsm_save.
     1927    {
     1928        paddr_t paddr = r_cc_receive_icache_nline.read() * m_icache_words * 4;
     1929        paddr_t mask  = ~((m_icache_words << 2) - 1);
    19461930
    19471931        // CLACK handler
     
    19491933        // and reset r_icache_miss_clack if the cleanup ack
    19501934        // is matching a pending miss.
    1951         if ( r_icache_clack_req.read() )
    1952         {
    1953 
    1954             if ( m_ireq.valid ) m_cost_ins_miss_frz++;
     1935        if (r_icache_clack_req.read())
     1936        {
     1937
     1938            if (m_ireq.valid) m_cost_ins_miss_frz++;
    19551939
    19561940#ifdef INSTRUMENTATION
    1957 m_cpt_icache_dir_write++;
    1958 #endif
    1959             r_icache.write_dir( 0,
    1960                                 r_icache_clack_way.read(),
    1961                                 r_icache_clack_set.read(),
    1962                                 CACHE_SLOT_STATE_EMPTY);
    1963 
    1964             if ( (r_icache_miss_set.read() == r_icache_clack_set.read()) and
    1965                  (r_icache_miss_way.read() == r_icache_clack_way.read()) )
     1941            m_cpt_icache_dir_write++;
     1942#endif
     1943            r_icache.write_dir(0,
     1944                               r_icache_clack_way.read(),
     1945                               r_icache_clack_set.read(),
     1946                               CACHE_SLOT_STATE_EMPTY);
     1947
     1948            if ((r_icache_miss_set.read() == r_icache_clack_set.read()) and
     1949                 (r_icache_miss_way.read() == r_icache_clack_way.read()))
    19661950            {
    19671951                r_icache_miss_clack = false;
     
    19741958
    19751959#if DEBUG_ICACHE
    1976 if ( m_debug_activated )
    1977 {
    1978     std::cout << "  <PROC " << name()
    1979         << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
    1980         << " set = " << r_icache_clack_set.read()
    1981         << " / way = " << r_icache_clack_way.read() << std::endl;
    1982 }
     1960            if (m_debug_activated)
     1961            {
     1962                std::cout << "  <PROC " << name()
     1963                    << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
     1964                    << " set = " << r_icache_clack_set.read()
     1965                    << " / way = " << r_icache_clack_way.read() << std::endl;
     1966            }
    19831967#endif
    19841968
     
    19901974        // because the CLACK access the directory but the MISS match dont.
    19911975        if (r_cc_receive_icache_req.read() and
    1992           ((r_icache_fsm_save.read() == ICACHE_MISS_SELECT  )  or
    1993            (r_icache_fsm_save.read() == ICACHE_MISS_WAIT    )  or
     1976          ((r_icache_fsm_save.read() == ICACHE_MISS_SELECT)  or
     1977           (r_icache_fsm_save.read() == ICACHE_MISS_WAIT)  or
    19941978           (r_icache_fsm_save.read() == ICACHE_MISS_DIR_UPDT)) and
    1995           ((r_icache_vci_paddr.read() & mask) == (paddr & mask)) ) // matching
     1979          ((r_icache_vci_paddr.read() & mask) == (paddr & mask))) // matching
    19961980        {
    19971981            // signaling the matching
    1998             r_icache_miss_inval     = true;
     1982            r_icache_miss_inval = true;
    19991983
    20001984            // in case of update, go to CC_UPDT
     
    20021986            if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
    20031987            {
    2004                 r_icache_fsm        = ICACHE_CC_UPDT;
    2005                 r_icache_cc_word    = r_cc_receive_word_idx.read();
     1988                r_icache_fsm = ICACHE_CC_UPDT;
     1989                r_icache_cc_word = r_cc_receive_word_idx.read();
    20061990
    20071991                // just pop the fifo , don't write in icache
     
    20121996            {
    20131997                r_cc_receive_icache_req = false;
    2014                 r_icache_fsm          = r_icache_fsm_save.read();
     1998                r_icache_fsm = r_icache_fsm_save.read();
    20151999            }
    20162000#if DEBUG_ICACHE
    2017 if ( m_debug_activated )
    2018 {
    2019     std::cout << "  <PROC " << name()
    2020               << " ICACHE_CC_CHECK> Coherence request matching a pending miss:"
    2021               << " PADDR = " << std::hex << paddr << std::endl;
    2022 }
    2023 #endif
    2024         }
    2025 
    2026         assert ( not r_icache_cc_send_req.read() and "CC_SEND must be available in ICACHE_CC_CHECK");
     2001            if (m_debug_activated)
     2002            {
     2003                std::cout << "  <PROC " << name()
     2004                    << " ICACHE_CC_CHECK> Coherence request matching a pending miss:"
     2005                    << " PADDR = " << std::hex << paddr << std::endl;
     2006            }
     2007#endif
     2008        }
     2009
     2010        assert(not r_icache_cc_send_req.read() and "CC_SEND must be available in ICACHE_CC_CHECK");
    20272011
    20282012        // CC request handler
    20292013
    2030         int         state = 0;
    2031         size_t      way = 0;
    2032         size_t      set = 0;
    2033         size_t      word = 0;
     2014        int    state = 0;
     2015        size_t way = 0;
     2016        size_t set = 0;
     2017        size_t word = 0;
    20342018
    20352019#ifdef INSTRUMENTATION
    2036 m_cpt_icache_dir_read++;
     2020        m_cpt_icache_dir_read++;
    20372021#endif
    20382022        r_icache.read_dir(paddr,
     
    20452029        r_icache_cc_set = set;
    20462030
    2047         if ( state == CACHE_SLOT_STATE_VALID_CC)            // hit
     2031        if (state == CACHE_SLOT_STATE_VALID_CC)            // hit
    20482032        {
    20492033            // need to update the cache state
     
    20512035            {
    20522036                r_icache_cc_need_write = true;
    2053                 r_icache_fsm           = ICACHE_CC_UPDT;
    2054                 r_icache_cc_word       = r_cc_receive_word_idx.read();
    2055             }
    2056             else if ( r_cc_receive_icache_type.read() == CC_TYPE_INVAL ) // hit inval
    2057             {
    2058                 r_icache_fsm           = ICACHE_CC_INVAL;
     2037                r_icache_fsm = ICACHE_CC_UPDT;
     2038                r_icache_cc_word = r_cc_receive_word_idx.read();
     2039            }
     2040            else if (r_cc_receive_icache_type.read() == CC_TYPE_INVAL) // hit inval
     2041            {
     2042                r_icache_fsm = ICACHE_CC_INVAL;
    20592043            }
    20602044        }
     
    20622046        {
    20632047            // multicast acknowledgement required in case of update
    2064             if(r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
    2065             {
    2066                 r_icache_fsm           = ICACHE_CC_UPDT;
    2067                 r_icache_cc_word       = r_cc_receive_word_idx.read();
     2048            if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
     2049            {
     2050                r_icache_fsm = ICACHE_CC_UPDT;
     2051                r_icache_cc_word = r_cc_receive_word_idx.read();
    20682052
    20692053                // just pop the fifo , don't write in icache
     
    20732057            {
    20742058                r_cc_receive_icache_req = false;
    2075                 r_icache_fsm            = r_icache_fsm_save.read();
     2059                r_icache_fsm = r_icache_fsm_save.read();
    20762060            }
    20772061        }
    20782062#if DEBUG_ICACHE
    2079 if ( m_debug_activated )
    2080 {
    2081     std::cout << "  <PROC " << name()
    2082               << " ICACHE_CC_CHECK> Coherence request received:"
    2083               << " PADDR = " << std::hex << paddr
    2084               << " / TYPE = " << std::dec << r_cc_receive_dcache_type.read()
    2085               << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) << std::endl;
    2086 }
    2087 #endif
    2088 
     2063        if (m_debug_activated)
     2064        {
     2065            std::cout << "  <PROC " << name()
     2066                << " ICACHE_CC_CHECK> Coherence request received:"
     2067                << " PADDR = " << std::hex << paddr
     2068                << " / TYPE = " << std::dec << r_cc_receive_dcache_type.read()
     2069                << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) << std::endl;
     2070        }
     2071#endif
    20892072        break;
    20902073    }
    20912074    /////////////////////
    2092     case ICACHE_CC_INVAL:   // hit inval : switch slot to ZOMBI state
    2093     {
    2094         assert (not r_icache_cc_send_req.read() &&
    2095                 "ERROR in ICACHE_CC_INVAL: the r_icache_cc_send_req "
    2096                 "must not be set");
     2075    case ICACHE_CC_INVAL:  // hit inval : switch slot to ZOMBI state
     2076    {
     2077        assert(not r_icache_cc_send_req.read() and
     2078               "ERROR in ICACHE_CC_INVAL: the r_icache_cc_send_req "
     2079               "must not be set");
    20972080
    20982081#ifdef INSTRUMENTATION
    2099 m_cpt_icache_dir_read++;
     2082        m_cpt_icache_dir_read++;
    21002083#endif
    21012084
    21022085        // Switch slot state to ZOMBI and send CLEANUP command
    2103         r_icache.write_dir( r_icache_cc_way.read(),
    2104                             r_icache_cc_set.read(),
    2105                             CACHE_SLOT_STATE_ZOMBI );
     2086        r_icache.write_dir(r_icache_cc_way.read(),
     2087                           r_icache_cc_set.read(),
     2088                           CACHE_SLOT_STATE_ZOMBI);
    21062089
    21072090        // coherence request completed
     
    21112094        r_icache_cc_send_type  = CC_TYPE_CLEANUP;
    21122095
    2113         r_icache_fsm           = r_icache_fsm_save.read();
     2096        r_icache_fsm = r_icache_fsm_save.read();
    21142097
    21152098#if DEBUG_ICACHE
    2116 if ( m_debug_activated )
    2117 {
    2118 std::cout << "  <PROC " << name()
    2119           << " ICACHE_CC_INVAL> slot returns to ZOMBI state"
    2120           << " set = " << r_icache_cc_set.read()
    2121           << " / way = " << r_icache_cc_way.read() << std::endl;
    2122 }
     2099        if (m_debug_activated)
     2100        {
     2101            std::cout << "  <PROC " << name()
     2102                << " ICACHE_CC_INVAL> slot returns to ZOMBI state"
     2103                << " set = " << r_icache_cc_set.read()
     2104                << " / way = " << r_icache_cc_way.read() << std::endl;
     2105        }
    21232106#endif
    21242107
     
    21262109    }
    21272110    ////////////////////
    2128     case ICACHE_CC_UPDT:    // hit update : write one word per cycle
    2129     {
    2130         assert (not r_icache_cc_send_req.read() &&
    2131                 "ERROR in ICACHE_CC_UPDT: the r_icache_cc_send_req "
    2132                 "must not be set");
    2133 
    2134         if ( not r_cc_receive_updt_fifo_be.rok() ) break;
    2135 
    2136 
    2137         size_t  word = r_icache_cc_word.read();
    2138         size_t  way   = r_icache_cc_way.read();
    2139         size_t  set   = r_icache_cc_set.read();
     2111    case ICACHE_CC_UPDT: // hit update : write one word per cycle
     2112    {
     2113        assert(not r_icache_cc_send_req.read() and
     2114               "ERROR in ICACHE_CC_UPDT: the r_icache_cc_send_req "
     2115               "must not be set");
     2116
     2117        if (not r_cc_receive_updt_fifo_be.rok()) break;
     2118
     2119
     2120        size_t word = r_icache_cc_word.read();
     2121        size_t way  = r_icache_cc_way.read();
     2122        size_t set  = r_icache_cc_set.read();
    21402123
    21412124        if (r_icache_cc_need_write.read())
    21422125        {
    2143             r_icache.write( way,
    2144                             set,
    2145                             word,
    2146                             r_cc_receive_updt_fifo_data.read(),
    2147                             r_cc_receive_updt_fifo_be.read() );
    2148 
    2149             r_icache_cc_word = word+1;
     2126            r_icache.write(way,
     2127                           set,
     2128                           word,
     2129                           r_cc_receive_updt_fifo_data.read(),
     2130                           r_cc_receive_updt_fifo_be.read());
     2131
     2132            r_icache_cc_word = word + 1;
    21502133
    21512134#ifdef INSTRUMENTATION
    2152 m_cpt_icache_data_write++;
     2135            m_cpt_icache_data_write++;
    21532136#endif
    21542137
    21552138#if DEBUG_ICACHE
    2156 if ( m_debug_activated )
    2157 {
    2158     std::cout << "  <PROC " << name()
    2159               << " ICACHE_CC_UPDT> Write one word "
    2160               << " set = " << r_icache_cc_set.read()
    2161               << " / way = " << r_icache_cc_way.read()
    2162               << " / word = " << r_icache_cc_word.read() << std::endl;
    2163 }
    2164 #endif
    2165         }
    2166 
    2167         if ( r_cc_receive_updt_fifo_eop.read() )  // last word
     2139            if (m_debug_activated)
     2140            {
     2141                std::cout << "  <PROC " << name()
     2142                    << " ICACHE_CC_UPDT> Write one word "
     2143                    << " set = " << r_icache_cc_set.read()
     2144                    << " / way = " << r_icache_cc_way.read()
     2145                    << " / word = " << r_icache_cc_word.read() << std::endl;
     2146            }
     2147#endif
     2148        }
     2149
     2150        if (r_cc_receive_updt_fifo_eop.read()) // last word
    21682151        {
    21692152            // no need to write in the cache anymore
    2170             r_icache_cc_need_write        = false;
     2153            r_icache_cc_need_write = false;
    21712154
    21722155            // coherence request completed
    2173             r_cc_receive_icache_req       = false;
     2156            r_cc_receive_icache_req = false;
    21742157
    21752158            // request multicast acknowledgement
     
    21792162            r_icache_cc_send_type         = CC_TYPE_MULTI_ACK;
    21802163
    2181             r_icache_fsm                  = r_icache_fsm_save.read();
     2164            r_icache_fsm = r_icache_fsm_save.read();
    21822165        }
    21832166        //consume fifo if not eop
    2184         cc_receive_updt_fifo_get  = true;
     2167        cc_receive_updt_fifo_get = true;
    21852168
    21862169        break;
     
    22432226    //    This component implement a strong order between non cacheable access
    22442227    //    (read or write) : A new non cacheable VCI transaction starts only when
    2245     //    the previous non cacheable transaction is completed. Both cacheable and
    2246     //    non cacheable transactions use the write buffer, but the DCACHE FSM registers
    2247     //    a non cacheable write transaction posted in the write buffer by setting the
    2248     //    r_dcache_pending_unc_write flip_flop. All other non cacheable requests
    2249     //    are stalled until this flip-flop is reset by the VCI_RSP_FSM (when the
    2250     //    pending non cacheable write transaction completes).
     2228    //    the previous non cacheable transaction is completed. After send the VCI
     2229    //    transaction, the DCACHE FSM wait for the respone in the DCACHE_UNC_WAIT state.
     2230    //    So the processor is blocked until the respone arrives in CACHE L1.
    22512231    //
    22522232    // 6/ Error handling:
    22532233    //    When the MMU is not activated, Read Bus Errors are synchronous events,
    2254     //    but Write Bus Errors are asynchronous events (processor is not frozen).
    2255     //    - If a Read Bus Error is detected, the VCI_RSP FSM sets the
     2234    //    Some Write Bus Errors are synchronous events when the request is a non cacheable access
     2235    //    but some Write Bus Errors are asynchronous events when the request is cacheable access
     2236    //    (processor is not frozen).
     2237    //    - If a Read Bus Error or a Non Cacheable Write Bus Error is detected, the VCI_RSP FSM sets the
    22562238    //      r_vci_rsp_data_error flip-flop, without writing any data in the
    22572239    //      r_vci_rsp_fifo_dcache FIFO, and the synchronous error is signaled
    22582240    //      by the DCACHE FSM.
    2259     //    - If a Write Bus Error is detected, the VCI_RSP FSM signals
    2260     //      the asynchronous error using the setWriteBerr() method.
     2241    //    - If a Cacheable Write Bus Error is detected, the VCI_RSP_FSM signals
     2242    //    the asynchronous error using the setWriteBerr() method.
    22612243    //    When the MMU is activated bus error are rare events, as the MMU
    22622244    //    checks the physical address before the VCI transaction starts.
     
    22682250    m_drsp.rdata = 0;
    22692251
    2270     switch ( r_dcache_fsm.read() )
     2252    switch (r_dcache_fsm.read())
    22712253    {
    22722254    case DCACHE_IDLE: // There are 10 conditions to exit the IDLE state :
     
    22782260                      // 6) Dirty bit update (processor)      => DCACHE_DIRTY_GET_PTE
    22792261                      // 7) Cacheable read miss (processor)   => DCACHE_MISS_SELECT
    2280                       // 8) Uncacheable read (processor)      => DCACHE_UNC_WAIT
     2262                      // 8) Uncacheable read/write (processor)=> DCACHE_UNC_WAIT
    22812263                      // 9) LL access (processor)             => DCACHE_LL_WAIT
    22822264                      // 10) SC access (processor)            => DCACHE_SC_WAIT
     
    23052287                      // updt_request, wbuf_request, wbuf_write_miss.
    23062288    {
    2307         paddr_t     paddr;                          // physical address
    2308         pte_info_t  tlb_flags;
    2309         size_t      tlb_way;
    2310         size_t      tlb_set;
    2311         paddr_t     tlb_nline = 0;
    2312         size_t      cache_way;
    2313         size_t      cache_set;
    2314         size_t      cache_word;
    2315         uint32_t    cache_rdata = 0;
    2316         bool        tlb_hit = false;
    2317         int         cache_state = CACHE_SLOT_STATE_EMPTY;
    2318 
    2319         bool        tlb_inval_required = false;    // request TLB inval after cache update
    2320         bool        wbuf_write_miss    = false;     // miss a WBUF write request
    2321         bool        updt_request       = false;     // request DCACHE update in P1 stage
    2322         bool        wbuf_request       = false;     // request WBUF write in P1 stage
    2323 
    2324         // physical address computation : systematic DTLB access (if activated)
     2289        paddr_t paddr;
     2290        pte_info_t tlb_flags;
     2291        size_t   tlb_way;
     2292        size_t   tlb_set;
     2293        paddr_t  tlb_nline = 0;
     2294        size_t   cache_way;
     2295        size_t   cache_set;
     2296        size_t   cache_word;
     2297        uint32_t cache_rdata = 0;
     2298        bool     tlb_hit = false;
     2299        int      cache_state = CACHE_SLOT_STATE_EMPTY;
     2300
     2301        bool tlb_inval_required = false; // request TLB inval after cache update
     2302        bool wbuf_write_miss = false;    // miss a WBUF write request
     2303        bool updt_request = false;       // request DCACHE update in P1 stage
     2304        bool wbuf_request = false;       // request WBUF write in P1 stage
     2305
     2306        // physical address computation : systematic DTLB access if activated
    23252307        paddr = (paddr_t) m_dreq.addr;
    2326         if ( m_dreq.valid )
    2327         {
    2328             if ( r_mmu_mode.read() & DATA_TLB_MASK )  // DTLB activated
    2329             {
    2330                 tlb_hit = r_dtlb.translate( m_dreq.addr,
    2331                                             &paddr,
    2332                                             &tlb_flags,
    2333                                             &tlb_nline,
    2334                                             &tlb_way,
    2335                                             &tlb_set );
     2308        if (m_dreq.valid)
     2309        {
     2310            if (r_mmu_mode.read() & DATA_TLB_MASK)  // DTLB activated
     2311            {
     2312                tlb_hit = r_dtlb.translate(m_dreq.addr,
     2313                                           &paddr,
     2314                                           &tlb_flags,
     2315                                           &tlb_nline,
     2316                                           &tlb_way,
     2317                                           &tlb_set);
    23362318#ifdef INSTRUMENTATION
    2337 m_cpt_data_tlb_read++;
    2338 #endif
    2339             }
    2340             else                                    // identity mapping
     2319                m_cpt_dtlb_read++;
     2320#endif
     2321            }
     2322            else // identity mapping
    23412323            {
    23422324                // we take into account the paddr extension
    23432325                if (vci_param::N > 32)
    2344                     paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
     2326                    paddr = paddr | ((paddr_t) (r_dcache_paddr_ext.read()) << 32);
    23452327            }
    23462328        } // end physical address computation
    23472329
    23482330        // systematic DCACHE access depending on r_dcache_updt_req (if activated)
    2349         if ( r_mmu_mode.read() & DATA_CACHE_MASK)
    2350         {
    2351 
    2352             if ( m_dreq.valid and r_dcache_updt_req.read() ) // read DIR and write DATA
    2353             {
    2354                 r_dcache.read_dir( paddr,
    2355                                    &cache_state,
    2356                                    &cache_way,
    2357                                    &cache_set,
    2358                                    &cache_word );
    2359 
    2360                 r_dcache.write( r_dcache_save_cache_way.read(),
    2361                                 r_dcache_save_cache_set.read(),
    2362                                 r_dcache_save_cache_word.read(),
    2363                                 r_dcache_save_wdata.read(),
    2364                                 r_dcache_save_be.read() );
     2331        if (r_mmu_mode.read() & DATA_CACHE_MASK)
     2332        {
     2333
     2334            if (m_dreq.valid and r_dcache_updt_req.read()) // read DIR and write DATA
     2335            {
     2336                r_dcache.read_dir(paddr,
     2337                                  &cache_state,
     2338                                  &cache_way,
     2339                                  &cache_set,
     2340                                  &cache_word);
     2341
     2342                r_dcache.write(r_dcache_save_cache_way.read(),
     2343                               r_dcache_save_cache_set.read(),
     2344                               r_dcache_save_cache_word.read(),
     2345                               r_dcache_save_wdata.read(),
     2346                               r_dcache_save_be.read());
    23652347#ifdef INSTRUMENTATION
    2366 m_cpt_dcache_dir_read++;
    2367 m_cpt_dcache_data_write++;
    2368 #endif
    2369             }
    2370             else if ( m_dreq.valid and not r_dcache_updt_req.read() ) // read DIR and DATA
    2371             {
    2372                 r_dcache.read( paddr,
    2373                                &cache_rdata,
    2374                                &cache_way,
    2375                                &cache_set,
    2376                                &cache_word,
    2377                                &cache_state );
     2348                m_cpt_dcache_dir_read++;
     2349                m_cpt_dcache_data_write++;
     2350#endif
     2351            }
     2352            else if (m_dreq.valid and not r_dcache_updt_req.read()) // read DIR and DATA
     2353            {
     2354                r_dcache.read(paddr,
     2355                              &cache_rdata,
     2356                              &cache_way,
     2357                              &cache_set,
     2358                              &cache_word,
     2359                              &cache_state);
    23782360
    23792361#ifdef INSTRUMENTATION
    2380 m_cpt_dcache_dir_read++;
    2381 m_cpt_dcache_data_read++;
    2382 #endif
    2383             }
    2384             else if ( not m_dreq.valid and r_dcache_updt_req.read() ) // write DATA
    2385             {
    2386                 r_dcache.write( r_dcache_save_cache_way.read(),
    2387                                 r_dcache_save_cache_set.read(),
    2388                                 r_dcache_save_cache_word.read(),
    2389                                 r_dcache_save_wdata.read(),
    2390                                 r_dcache_save_be.read() );
     2362                m_cpt_dcache_dir_read++;
     2363                m_cpt_dcache_data_read++;
     2364#endif
     2365            }
     2366            else if (not m_dreq.valid and r_dcache_updt_req.read()) // write DATA
     2367            {
     2368                r_dcache.write(r_dcache_save_cache_way.read(),
     2369                               r_dcache_save_cache_set.read(),
     2370                               r_dcache_save_cache_word.read(),
     2371                               r_dcache_save_wdata.read(),
     2372                               r_dcache_save_be.read());
    23912373#ifdef INSTRUMENTATION
    2392 m_cpt_dcache_data_write++;
     2374                m_cpt_dcache_data_write++;
    23932375#endif
    23942376            }
     
    23962378
    23972379        // DCACHE update in P1 stage can require ITLB / DTLB inval or flush
    2398         if ( r_dcache_updt_req.read() )
     2380        if (r_dcache_updt_req.read())
    23992381        {
    24002382            size_t way = r_dcache_save_cache_way.read();
    24012383            size_t set = r_dcache_save_cache_set.read();
    24022384
    2403             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    2404             {
    2405                 tlb_inval_required       = true;
    2406                 r_dcache_tlb_inval_set   = 0;
    2407                 r_dcache_tlb_inval_line  = r_dcache_save_paddr.read()>>
    2408                                            (uint32_log2(m_dcache_words<<2));
    2409 
    2410                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    2411             }
    2412             else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     2385            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
     2386            {
     2387                tlb_inval_required      = true;
     2388                r_dcache_tlb_inval_set  = 0;
     2389                r_dcache_tlb_inval_line = r_dcache_save_paddr.read() >>
     2390                                           (uint32_log2(m_dcache_words << 2));
     2391                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
     2392            }
     2393            else if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
    24132394            {
    24142395                r_itlb.reset();
    24152396                r_dtlb.reset();
    2416 
    2417                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     2397                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
    24182398            }
    24192399
    24202400#if DEBUG_DCACHE
    2421 if ( m_debug_activated )
    2422 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2423           << " Cache update in P1 stage" << std::dec
    2424           << " / WAY = " << r_dcache_save_cache_way.read()
    2425           << " / SET = " << r_dcache_save_cache_set.read()
    2426           << " / WORD = " << r_dcache_save_cache_word.read() << std::hex
    2427           << " / WDATA = " << r_dcache_save_wdata.read()
    2428           << " / BE = " << r_dcache_save_be.read() << std::endl;
     2401            if (m_debug_activated)
     2402            {
     2403                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2404                    << " Cache update in P1 stage" << std::dec
     2405                    << " / WAY = " << r_dcache_save_cache_way.read()
     2406                    << " / SET = " << r_dcache_save_cache_set.read()
     2407                    << " / WORD = " << r_dcache_save_cache_word.read() << std::hex
     2408                    << " / WDATA = " << r_dcache_save_wdata.read()
     2409                    << " / BE = " << r_dcache_save_be.read() << std::endl;
     2410            }
    24292411#endif
    24302412        } // end test TLB inval
     
    24332415        // Miss if the write request is non cacheable, and there is a pending
    24342416        // non cacheable write, or if the write buffer is full.
    2435         if ( r_dcache_wbuf_req.read() )
    2436         {
    2437             bool wok = r_wbuf.write( r_dcache_save_paddr.read(),
    2438                                      r_dcache_save_be.read(),
    2439                                      r_dcache_save_wdata.read(),
    2440                                      true );
    2441 /*#ifdef INSTRUMENTATION
    2442 m_cpt_wbuf_write++;
    2443 #endif*/
    2444 
    2445             if ( not wok ) // miss if write buffer full
     2417        if (r_dcache_wbuf_req.read())
     2418        {
     2419            bool wok = r_wbuf.write(r_dcache_save_paddr.read(),
     2420                                    r_dcache_save_be.read(),
     2421                                    r_dcache_save_wdata.read(),
     2422                                    true);
     2423#ifdef INSTRUMENTATION
     2424            m_cpt_wbuf_write++;
     2425#endif
     2426            if (not wok) // miss if write buffer full
    24462427            {
    24472428                wbuf_write_miss = true;
    2448              }
     2429            }
    24492430        } // end WBUF update
    24502431
     
    24532434
    24542435        // itlb/dtlb invalidation self-request
    2455         if ( tlb_inval_required )
     2436        if (tlb_inval_required)
    24562437        {
    24572438            r_dcache_fsm_scan_save = r_dcache_fsm.read();
     
    24602441
    24612442        // coherence clack request (from DSPIN CLACK)
    2462         else if ( r_dcache_clack_req.read() )
     2443        else if (r_dcache_clack_req.read())
    24632444        {
    24642445            r_dcache_fsm = DCACHE_CC_CHECK;
     
    24662447        }
    24672448        // coherence request (from CC_RECEIVE FSM)
    2468         else if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     2449        else if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    24692450        {
    24702451            r_dcache_fsm = DCACHE_CC_CHECK;
     
    24752456        // we don't take the processor request, and registers
    24762457        // are frozen in case of wbuf_write_miss
    2477         else if ( m_dreq.valid and not wbuf_write_miss )
     2458        else if (m_dreq.valid and not wbuf_write_miss)
    24782459        {
    24792460            // register processor request and DCACHE response
     
    24912472            if (m_dreq.type == iss_t::XTN_READ)
    24922473            {
    2493                 int xtn_opcode = (int)m_dreq.addr/4;
     2474                int xtn_opcode = (int)m_dreq.addr / 4;
    24942475
    24952476                // checking processor mode:
     
    25052486                else
    25062487                {
    2507                     switch( xtn_opcode )
     2488                    switch (xtn_opcode)
    25082489                    {
    25092490                    case iss_t::XTN_INS_ERROR_TYPE:
     
    25802561
    25812562                    default:
    2582                         r_mmu_detr = MMU_READ_UNDEFINED_XTN;
     2563                        r_mmu_detr   = MMU_READ_UNDEFINED_XTN;
    25832564                        r_mmu_dbvar  = m_dreq.addr;
    25842565                        m_drsp.valid = true;
     
    25982579            else if (m_dreq.type == iss_t::XTN_WRITE)
    25992580            {
    2600                 int xtn_opcode      = (int)m_dreq.addr/4;
     2581                int xtn_opcode      = (int) m_dreq.addr / 4;
    26012582                r_dcache_xtn_opcode = xtn_opcode;
    26022583
    26032584                // checking processor mode:
    2604                 if ( (m_dreq.mode == iss_t::MODE_USER) &&
    2605                      (xtn_opcode != iss_t::XTN_SYNC) &&
    2606                      (xtn_opcode != iss_t::XTN_DCACHE_INVAL) &&
    2607                      (xtn_opcode != iss_t::XTN_DCACHE_FLUSH) &&
    2608                      (xtn_opcode != iss_t::XTN_ICACHE_INVAL) &&
    2609                      (xtn_opcode != iss_t::XTN_ICACHE_FLUSH) )
     2585                if ((m_dreq.mode == iss_t::MODE_USER) &&
     2586                    (xtn_opcode != iss_t::XTN_SYNC) &&
     2587                    (xtn_opcode != iss_t::XTN_DCACHE_INVAL) &&
     2588                    (xtn_opcode != iss_t::XTN_DCACHE_FLUSH) &&
     2589                    (xtn_opcode != iss_t::XTN_ICACHE_INVAL) &&
     2590                    (xtn_opcode != iss_t::XTN_ICACHE_FLUSH))
    26102591                {
    26112592                    r_mmu_detr   = MMU_WRITE_PRIVILEGE_VIOLATION;
     
    26182599                else
    26192600                {
    2620                     switch( xtn_opcode )
     2601                    switch (xtn_opcode)
    26212602                    {
    2622                     case iss_t::XTN_PTPR:               // itlb & dtlb must be flushed
     2603                    case iss_t::XTN_PTPR: // itlb & dtlb must be flushed
    26232604                        r_dcache_xtn_req = true;
    26242605                        r_dcache_fsm     = DCACHE_XTN_SWITCH;
    26252606                        break;
    26262607
    2627                     case iss_t::XTN_TLB_MODE:           // no cache or tlb access
    2628                         r_mmu_mode       = m_dreq.wdata;
    2629                         m_drsp.valid     = true;
    2630                         r_dcache_fsm     = DCACHE_IDLE;
     2608                    case iss_t::XTN_TLB_MODE: // no cache or tlb access
     2609                        r_mmu_mode   = m_dreq.wdata;
     2610                        m_drsp.valid = true;
     2611                        r_dcache_fsm = DCACHE_IDLE;
    26312612                        break;
    26322613
    2633                     case iss_t::XTN_DTLB_INVAL:             // dtlb access
    2634                         r_dcache_fsm     = DCACHE_XTN_DT_INVAL;
     2614                    case iss_t::XTN_DTLB_INVAL: // dtlb access
     2615                        r_dcache_fsm = DCACHE_XTN_DT_INVAL;
    26352616                        break;
    26362617
    2637                     case iss_t::XTN_ITLB_INVAL:             // itlb access
     2618                    case iss_t::XTN_ITLB_INVAL: // itlb access
    26382619                        r_dcache_xtn_req = true;
    26392620                        r_dcache_fsm     = DCACHE_XTN_IT_INVAL;
    26402621                        break;
    26412622
    2642                     case iss_t::XTN_DCACHE_INVAL:           // dcache, dtlb & itlb access
    2643                         r_dcache_fsm     = DCACHE_XTN_DC_INVAL_VA;
     2623                    case iss_t::XTN_DCACHE_INVAL:  // dcache, dtlb & itlb access
     2624                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_VA;
    26442625                        break;
    26452626
    2646                     case iss_t::XTN_MMU_DCACHE_PA_INV:      // dcache, dtlb & itlb access
    2647                         r_dcache_fsm     = DCACHE_XTN_DC_INVAL_PA;
     2627                    case iss_t::XTN_MMU_DCACHE_PA_INV: // dcache, dtlb & itlb access
     2628                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_PA;
    26482629                        if (sizeof(paddr_t) <= 32)
    26492630                        {
     
    26592640                        break;
    26602641
    2661                     case iss_t::XTN_DCACHE_FLUSH:           // itlb and dtlb must be reset
     2642                    case iss_t::XTN_DCACHE_FLUSH: // itlb and dtlb must be reset
    26622643                        r_dcache_flush_count = 0;
    2663                         r_dcache_fsm     = DCACHE_XTN_DC_FLUSH;
     2644                        r_dcache_fsm         = DCACHE_XTN_DC_FLUSH;
    26642645                        break;
    26652646
    2666                     case iss_t::XTN_ICACHE_INVAL:           // icache and itlb access
     2647                    case iss_t::XTN_ICACHE_INVAL: // icache and itlb access
    26672648                        r_dcache_xtn_req = true;
    26682649                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_VA;
    26692650                        break;
    26702651
    2671                     case iss_t::XTN_MMU_ICACHE_PA_INV:      // icache access
     2652                    case iss_t::XTN_MMU_ICACHE_PA_INV: // icache access
    26722653                        r_dcache_xtn_req = true;
    26732654                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_PA;
    26742655                        break;
    26752656
    2676                     case iss_t::XTN_ICACHE_FLUSH:           // icache access
     2657                    case iss_t::XTN_ICACHE_FLUSH:   // icache access
    26772658                        r_dcache_xtn_req = true;
    26782659                        r_dcache_fsm     = DCACHE_XTN_IC_FLUSH;
    26792660                        break;
    26802661
    2681                     case iss_t::XTN_SYNC:                   // wait until write buffer empty
    2682                         r_dcache_fsm     = DCACHE_XTN_SYNC;
     2662                    case iss_t::XTN_SYNC:           // wait until write buffer empty
     2663                        r_dcache_fsm = DCACHE_XTN_SYNC;
    26832664                        break;
    26842665
    2685                     case iss_t::XTN_MMU_WORD_LO:        // no cache or tlb access
    2686                         r_mmu_word_lo    = m_dreq.wdata;
    2687                         m_drsp.valid     = true;
    2688                         r_dcache_fsm     = DCACHE_IDLE;
     2666                    case iss_t::XTN_MMU_WORD_LO:    // no cache or tlb access
     2667                        r_mmu_word_lo = m_dreq.wdata;
     2668                        m_drsp.valid  = true;
     2669                        r_dcache_fsm  = DCACHE_IDLE;
    26892670                        break;
    26902671
    2691                     case iss_t::XTN_MMU_WORD_HI:        // no cache or tlb access
    2692                         r_mmu_word_hi    = m_dreq.wdata;
    2693                         m_drsp.valid     = true;
    2694                         r_dcache_fsm     = DCACHE_IDLE;
     2672                    case iss_t::XTN_MMU_WORD_HI:    // no cache or tlb access
     2673                        r_mmu_word_hi = m_dreq.wdata;
     2674                        m_drsp.valid  = true;
     2675                        r_dcache_fsm  = DCACHE_IDLE;
    26952676                        break;
    26962677
    2697                     case iss_t::XTN_MMU_LL_RESET:      // no cache or tlb access
     2678                    case iss_t::XTN_MMU_LL_RESET:   // no cache or tlb access
    26982679                        r_dcache_llsc_valid = false;
    2699                         m_drsp.valid     = true;
    2700                         r_dcache_fsm     = DCACHE_IDLE;
     2680                        m_drsp.valid        = true;
     2681                        r_dcache_fsm        = DCACHE_IDLE;
    27012682                    break;
    27022683
    2703                     case iss_t::XTN_DATA_PADDR_EXT:     // no cache or tlb access
     2684                    case iss_t::XTN_DATA_PADDR_EXT:  // no cache or tlb access
    27042685                        r_dcache_paddr_ext = m_dreq.wdata;
    27052686                        m_drsp.valid       = true;
     
    27072688                    break;
    27082689
    2709                     case iss_t::XTN_INST_PADDR_EXT:     // no cache or tlb access
     2690                    case iss_t::XTN_INST_PADDR_EXT:  // no cache or tlb access
    27102691                        r_dcache_xtn_req = true;
    27112692                        r_dcache_fsm     = DCACHE_XTN_IC_PADDR_EXT;
    27122693                    break;
    27132694
    2714                     case iss_t::XTN_ICACHE_PREFETCH:        // not implemented : no action
    2715                     case iss_t::XTN_DCACHE_PREFETCH:        // not implemented : no action
    2716                         m_drsp.valid     = true;
    2717                         r_dcache_fsm     = DCACHE_IDLE;
     2695                    case iss_t::XTN_ICACHE_PREFETCH: // not implemented : no action
     2696                    case iss_t::XTN_DCACHE_PREFETCH: // not implemented : no action
     2697                        m_drsp.valid = true;
     2698                        r_dcache_fsm = DCACHE_IDLE;
    27182699                    break;
    27192700
     
    27392720            else
    27402721            {
    2741                 bool        valid_req;
    2742                 bool        cacheable;
    2743 
    2744                 if ( not (r_mmu_mode.read() & DATA_TLB_MASK) )    // dtlb not activated
    2745                 {
    2746                     valid_req     = true;
    2747 
    2748                     if ( not (r_mmu_mode.read() & DATA_CACHE_MASK) ) cacheable = false;
     2722                bool valid_req;
     2723                bool cacheable;
     2724
     2725                if (not (r_mmu_mode.read() & DATA_TLB_MASK)) // dtlb not activated
     2726                {
     2727                    valid_req = true;
     2728
     2729                    if (not (r_mmu_mode.read() & DATA_CACHE_MASK)) cacheable = false;
    27492730                    else cacheable = m_cacheability_table[(uint64_t)m_dreq.addr];
    27502731                }
    2751                 else                                               // dtlb activated
    2752                 {
    2753                     if ( tlb_hit )                  // tlb hit
     2732                else // dtlb activated
     2733                {
     2734                    if (tlb_hit) // tlb hit
    27542735                    {
    27552736                        // cacheability
    2756                         if ( not (r_mmu_mode.read() & DATA_CACHE_MASK) ) cacheable = false;
     2737                        if (not (r_mmu_mode.read() & DATA_CACHE_MASK)) cacheable = false;
    27572738                        else cacheable = tlb_flags.c;
     2739
    27582740                        // access rights checking
    2759                         if ( not tlb_flags.u and (m_dreq.mode == iss_t::MODE_USER))
     2741                        if (not tlb_flags.u and (m_dreq.mode == iss_t::MODE_USER))
    27602742                        {
    2761                             if ( (m_dreq.type == iss_t::DATA_READ) or
    2762                                  (m_dreq.type == iss_t::DATA_LL) )
     2743                            if ((m_dreq.type == iss_t::DATA_READ) or
     2744                                (m_dreq.type == iss_t::DATA_LL))
    27632745                            {
    27642746                                r_mmu_detr = MMU_READ_PRIVILEGE_VIOLATION;
     
    27742756                            m_drsp.rdata = 0;
    27752757#if DEBUG_DCACHE
    2776 if ( m_debug_activated )
    2777 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2778           << " HIT in dtlb, but privilege violation" << std::endl;
     2758                            if (m_debug_activated)
     2759                            {
     2760                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2761                                    << " HIT in dtlb, but privilege violation" << std::endl;
     2762                            }
    27792763#endif
    27802764                        }
    2781                         else if ( not tlb_flags.w and
     2765                        else if (not tlb_flags.w and
    27822766                                  ((m_dreq.type == iss_t::DATA_WRITE) or
    2783                                    (m_dreq.type == iss_t::DATA_SC)) )
     2767                                   (m_dreq.type == iss_t::DATA_SC)))
    27842768                        {
    27852769                            r_mmu_detr   = MMU_WRITE_ACCES_VIOLATION;
     
    27902774                            m_drsp.rdata = 0;
    27912775#if DEBUG_DCACHE
    2792 if ( m_debug_activated )
    2793 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2794           << " HIT in dtlb, but writable violation" << std::endl;
     2776                            if (m_debug_activated)
     2777                            {
     2778                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2779                                    << " HIT in dtlb, but writable violation" << std::endl;
     2780                            }
    27952781#endif
    27962782                        }
    27972783                        else
    27982784                        {
    2799                             valid_req    = true;
     2785                            valid_req = true;
    28002786                        }
    28012787                    }
    2802                     else                     // tlb miss
     2788                    else // tlb miss
    28032789                    {
    2804                         valid_req            = false;
    2805                         r_dcache_tlb_vaddr   = m_dreq.addr;
    2806                         r_dcache_tlb_ins     = false;
    2807                         r_dcache_fsm         = DCACHE_TLB_MISS;
     2790                        valid_req          = false;
     2791                        r_dcache_tlb_vaddr = m_dreq.addr;
     2792                        r_dcache_tlb_ins   = false;
     2793                        r_dcache_fsm       = DCACHE_TLB_MISS;
    28082794                    }
    28092795                }    // end DTLB activated
    28102796
    2811                 if ( valid_req )    // processor request is valid (after MMU check)
     2797                if (valid_req) // processor request is valid (after MMU check)
    28122798                {
    28132799                    // READ request
     
    28152801                    // We request a VCI transaction to CMD FSM if miss or uncachable
    28162802
    2817                     if ( ((m_dreq.type == iss_t::DATA_READ))
    2818                           and not r_dcache_updt_req.read() )
     2803                    if (((m_dreq.type == iss_t::DATA_READ))
     2804                          and not r_dcache_updt_req.read())
    28192805                    {
    2820                         if ( cacheable )            // cacheable read
     2806                        if (cacheable) // cacheable read
    28212807                        {
    2822                             if ( cache_state == CACHE_SLOT_STATE_EMPTY )   // cache miss
     2808                            if (cache_state == CACHE_SLOT_STATE_EMPTY)   // cache miss
    28232809                            {
    28242810#ifdef INSTRUMENTATION
    2825 m_cpt_data_miss++;
     2811                                m_cpt_dcache_miss++;
    28262812#endif
    28272813                                // request a VCI DMISS transaction
     
    28312817                                r_dcache_fsm          = DCACHE_MISS_SELECT;
    28322818#if DEBUG_DCACHE
    2833 if ( m_debug_activated )
    2834 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2835           << " READ MISS in dcache"
    2836           << " / PADDR = " << std::hex << paddr << std::endl;
     2819                                if (m_debug_activated)
     2820                                {
     2821                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2822                                        << " READ MISS in dcache"
     2823                                        << " / PADDR = " << std::hex << paddr << std::endl;
     2824                                }
    28372825#endif
    28382826                            }
    2839                             else if (cache_state == CACHE_SLOT_STATE_ZOMBI ) // pending cleanup
     2827                            else if (cache_state == CACHE_SLOT_STATE_ZOMBI) // pending cleanup
    28402828                            {
    28412829                                // stalled until cleanup is acknowledged
    28422830                                r_dcache_fsm   = DCACHE_IDLE;
    28432831#if DEBUG_DCACHE
    2844 if ( m_debug_activated )
    2845 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2846           << " Pending cleanup, stalled until cleanup acknowledge"
    2847           << " / PADDR = " << std::hex << paddr << std::endl;
     2832                                if (m_debug_activated)
     2833                                {
     2834                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2835                                        << " Pending cleanup, stalled until cleanup acknowledge"
     2836                                        << " / PADDR = " << std::hex << paddr << std::endl;
     2837                                }
    28482838#endif
    28492839                            }
     
    28512841                            {
    28522842#ifdef INSTRUMENTATION
    2853 m_cpt_data_read++;
     2843                                m_cpt_data_read++;
    28542844#endif
    28552845                                // returns data to processor
    2856                                 m_drsp.valid   = true;
    2857                                 m_drsp.error   = false;
    2858                                 m_drsp.rdata   = cache_rdata;
     2846                                m_drsp.valid = true;
     2847                                m_drsp.error = false;
     2848                                m_drsp.rdata = cache_rdata;
    28592849#if DEBUG_DCACHE
    2860 if ( m_debug_activated )
    2861 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2862           << " READ HIT in dcache"
    2863           << " : PADDR = " << std::hex << paddr
    2864           << " / DATA  = " << std::hex << cache_rdata << std::dec << std::endl;
     2850                                if (m_debug_activated)
     2851                                {
     2852                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2853                                        << " READ HIT in dcache"
     2854                                        << " : PADDR = " << std::hex << paddr
     2855                                        << " / DATA  = " << std::hex << cache_rdata << std::dec << std::endl;
     2856                                }
    28652857#endif
    28662858                            }
    28672859                        }
    2868                         else                    // uncacheable read
     2860                        else // uncacheable read
    28692861                        {
    2870                             r_dcache_vci_paddr      = paddr;
    2871                             r_dcache_vci_unc_be     = m_dreq.be;
    2872                             r_dcache_vci_unc_write  = false;
    2873                             r_dcache_vci_unc_req    = true;
    2874                             r_dcache_fsm            = DCACHE_UNC_WAIT;
     2862                            r_dcache_vci_paddr     = paddr;
     2863                            r_dcache_vci_unc_be    = m_dreq.be;
     2864                            r_dcache_vci_unc_write = false;
     2865                            r_dcache_vci_unc_req   = true;
     2866                            r_dcache_fsm           = DCACHE_UNC_WAIT;
    28752867#if DEBUG_DCACHE
    2876 if ( m_debug_activated )
    2877 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2878           << " READ UNCACHEABLE in dcache"
    2879           << " / PADDR = " << std::hex << paddr << std::endl;
     2868                            if (m_debug_activated)
     2869                            {
     2870                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2871                                    << " READ UNCACHEABLE in dcache"
     2872                                    << " / PADDR = " << std::hex << paddr << std::endl;
     2873                            }
    28802874#endif
    28812875                        }
     
    29082902                    // physical address) are registered in r_dcache_save registers,
    29092903                    // and the write will be done in the P1 pipeline stage.
    2910                     else if ( m_dreq.type == iss_t::DATA_WRITE )
     2904                    else if (m_dreq.type == iss_t::DATA_WRITE)
    29112905                    {
    2912                         if ( (r_mmu_mode.read() & DATA_TLB_MASK )
    2913                               and not tlb_flags.d )    // Dirty bit must be set
     2906                        if ((r_mmu_mode.read() & DATA_TLB_MASK)
     2907                              and not tlb_flags.d) // Dirty bit must be set
    29142908                        {
    29152909                            // The PTE physical address is obtained from the nline value (dtlb),
    29162910                            // and from the virtual address (word index)
    2917                             if ( tlb_flags.b ) // PTE1
     2911                            if (tlb_flags.b) // PTE1
    29182912                            {
    2919                                 r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
    2920                                                        (paddr_t)((m_dreq.addr>>19) & 0x3c);
     2913                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
     2914                                                       (paddr_t) ((m_dreq.addr >> 19) & 0x3c);
    29212915                            }
    2922                             else        // PTE2
     2916                            else // PTE2
    29232917                            {
    2924                                 r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
    2925                                                        (paddr_t)((m_dreq.addr>>9) & 0x38);
     2918                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
     2919                                                       (paddr_t) ((m_dreq.addr >> 9) & 0x38);
    29262920                            }
    2927                             r_dcache_fsm      = DCACHE_DIRTY_GET_PTE;
     2921                            r_dcache_fsm = DCACHE_DIRTY_GET_PTE;
    29282922                        }
    2929                         else                    // Write request accepted
     2923                        else // Write request accepted
    29302924                        {
    29312925#ifdef INSTRUMENTATION
    2932 m_cpt_data_write++;
     2926                            m_cpt_data_write++;
    29332927#endif
    29342928                            // cleaning llsc buffer if address matching
    2935                             if ( paddr == r_dcache_llsc_paddr.read() )
     2929                            if (paddr == r_dcache_llsc_paddr.read())
    29362930                                r_dcache_llsc_valid = false;
    29372931
    2938                             if (not cacheable)
     2932                            if (not cacheable) // uncacheable write
    29392933                            {
    2940                                 r_dcache_vci_paddr      = paddr;
    2941                                 r_dcache_vci_wdata      = m_dreq.wdata;
    2942                                 r_dcache_vci_unc_write  = true;
    2943                                 r_dcache_vci_unc_be     = m_dreq.be;
    2944                                 r_dcache_vci_unc_req    = true;
    2945                                 r_dcache_fsm            = DCACHE_UNC_WAIT;
     2934                                r_dcache_vci_paddr     = paddr;
     2935                                r_dcache_vci_wdata     = m_dreq.wdata;
     2936                                r_dcache_vci_unc_write = true;
     2937                                r_dcache_vci_unc_be    = m_dreq.be;
     2938                                r_dcache_vci_unc_req   = true;
     2939                                r_dcache_fsm           = DCACHE_UNC_WAIT;
    29462940                            }
    29472941                            // activating P1 stage
    2948                             else if( (cache_state != CACHE_SLOT_STATE_ZOMBI) && (cache_state != CACHE_SLOT_STATE_EMPTY) )
     2942                            else if ((cache_state != CACHE_SLOT_STATE_ZOMBI) and
     2943                                     (cache_state != CACHE_SLOT_STATE_EMPTY))
    29492944                            {
    2950                                 wbuf_request = (cache_state == CACHE_SLOT_STATE_VALID_CC); //write to L2 only if CC
     2945                                wbuf_request = (cache_state == CACHE_SLOT_STATE_VALID_CC);
    29512946                                updt_request = true;
    29522947                                m_drsp.valid = true;
    2953                                 if ( cache_state == CACHE_SLOT_STATE_VALID_NCC )
     2948                                if (cache_state == CACHE_SLOT_STATE_VALID_NCC)
    29542949                                {
    2955                                     if ( r_dcache_content_state[cache_way*m_dcache_sets+cache_set] == LINE_CACHE_DATA_NOT_DIRTY )
     2950                                    if (r_dcache_content_state[cache_way * m_dcache_sets + cache_set] == LINE_CACHE_DATA_NOT_DIRTY)
    29562951                                    {
    2957                                         r_dcache_content_state[cache_way*m_dcache_sets+cache_set] = LINE_CACHE_DATA_DIRTY;
     2952                                        r_dcache_content_state[cache_way * m_dcache_sets + cache_set] = LINE_CACHE_DATA_DIRTY;
    29582953                                    }
    2959                                     //dirty bit with word granularity (only for stats)
    2960                                     r_dcache_dirty_word[(cache_way*m_dcache_sets +cache_set)*m_dcache_words+cache_word] = 1;
     2954                                    // dirty bit with word granularity (only for stats)
     2955                                    r_dcache_dirty_word[(cache_way * m_dcache_sets + cache_set) * m_dcache_words + cache_word] = 1;
    29612956                                    m_cpt_data_write_back ++;
    29622957                                }
     
    29712966                            // cleanup and therefore overwrite the new value of
    29722967                            // writing that is more current than the data
    2973                             // contained in the cleanup .
     2968                            // contained in the cleanup.
    29742969                            // TODO : MAYBE NEED TO OPTIMIZE
    2975                             else if ( cache_state == CACHE_SLOT_STATE_ZOMBI )
     2970                            else if (cache_state == CACHE_SLOT_STATE_ZOMBI)
    29762971                            {
    29772972                                m_drsp.valid = false;
    29782973                                r_dcache_fsm = DCACHE_IDLE;
    29792974                                // STAT : WRITE ON ZOMBI NCC LINE
    2980                                 if (r_dcache_zombi_ncc[cache_way*m_dcache_sets+cache_set] == true)
     2975                                if (r_dcache_zombi_ncc[cache_way * m_dcache_sets + cache_set] == true)
    29812976                                {
    29822977                                    m_cpt_data_write_on_zombi_ncc++;
    29832978                                }
    2984 
    29852979                                m_cpt_data_write_on_zombi++;
    29862980                            }
     
    29942988                        }
    29952989#if DEBUG_DCACHE
    2996 if ( m_debug_activated )
    2997 std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2998           << " WRITE REQ "
    2999           << " / wbuf_request = " << wbuf_request
    3000           << " / updt_request = " << updt_request
    3001           << " / cache_state = " << cache_state
    3002           << " / PADDR = " << std::hex << paddr << std::endl;
    3003 #endif
    3004 
     2990                        if (m_debug_activated)
     2991                        {
     2992                            std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
     2993                                << " WRITE REQ "
     2994                                << " / wbuf_request = " << wbuf_request
     2995                                << " / updt_request = " << updt_request
     2996                                << " / cache_state = " << cache_state
     2997                                << " / PADDR = " << std::hex << paddr << std::dec << std::endl;
     2998                        }
     2999#endif
    30053000                    } // end WRITE
    30063001
     
    30153010                    // We don't check a possible write hit in dcache, as the cache update
    30163011                    // is done by the coherence transaction induced by the SC...
    3017                     else if ( m_dreq.type == iss_t::DATA_SC )
     3012                    else if (m_dreq.type == iss_t::DATA_SC)
    30183013                    {
    3019                         if ( (r_mmu_mode.read() & DATA_TLB_MASK )
    3020                               and not tlb_flags.d )        // Dirty bit must be set
     3014                        if ((r_mmu_mode.read() & DATA_TLB_MASK)
     3015                              and not tlb_flags.d) // Dirty bit must be set
    30213016                        {
    30223017                            // The PTE physical address is obtained from the nline value (dtlb),
    30233018                            // and the word index (virtual address)
    3024                             if ( tlb_flags.b ) // PTE1
     3019                            if (tlb_flags.b) // PTE1
    30253020                            {
    3026                                 r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
    3027                                                        (paddr_t)((m_dreq.addr>>19) & 0x3c);
     3021                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
     3022                                                       (paddr_t) ((m_dreq.addr >> 19) & 0x3c);
    30283023                            }
    3029                             else            // PTE2
     3024                            else // PTE2
    30303025                            {
    3031                                 r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
    3032                                                        (paddr_t)((m_dreq.addr>>9) & 0x38);
     3026                                r_dcache_dirty_paddr = (paddr_t) (tlb_nline * (m_dcache_words << 2)) |
     3027                                                       (paddr_t) ((m_dreq.addr >> 9) & 0x38);
    30333028                            }
    3034                             r_dcache_fsm           = DCACHE_DIRTY_GET_PTE;
     3029                            r_dcache_fsm = DCACHE_DIRTY_GET_PTE;
    30353030                            m_drsp.valid = false;
    30363031                            m_drsp.error = false;
    30373032                            m_drsp.rdata = 0;
    30383033                        }
    3039                         else                    // SC request accepted
     3034                        else // SC request accepted
    30403035                        {
    30413036#ifdef INSTRUMENTATION
    3042 m_cpt_data_sc++;
     3037                            m_cpt_data_sc++;
    30433038#endif
    30443039                            // checking local success
    3045                             if( r_dcache_llsc_valid.read() and
    3046                                 (r_dcache_llsc_paddr.read() == paddr) ) // local success
     3040                            if (r_dcache_llsc_valid.read() and
     3041                               (r_dcache_llsc_paddr.read() == paddr)) // local success
    30473042                            {
    30483043                                // request an SC CMD and go to DCACHE_SC_WAIT state
     
    30523047                                r_dcache_fsm         = DCACHE_SC_WAIT;
    30533048                            }
    3054                             else                                          // local fail
     3049                            else // local fail
    30553050                            {
    30563051                                m_drsp.valid = true;
     
    30653060
    30663061        // itlb miss request
    3067         else if ( r_icache_tlb_miss_req.read() and not wbuf_write_miss )
     3062        else if (r_icache_tlb_miss_req.read() and not wbuf_write_miss)
    30683063        {
    30693064            r_dcache_tlb_ins    = true;
     
    30913086                          // r_mmu_ins_* or r_mmu_data* error reporting registers.
    30923087    {
    3093         uint32_t    ptba = 0;
    3094         bool        bypass;
    3095         paddr_t     pte_paddr;
     3088        uint32_t ptba = 0;
     3089        bool     bypass;
     3090        paddr_t  pte_paddr;
    30963091
    30973092        // evaluate bypass in order to skip first level page table access
    3098         if ( r_dcache_tlb_ins.read() ) // itlb miss
     3093        if (r_dcache_tlb_ins.read()) // itlb miss
    30993094        {
    31003095            bypass = r_itlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
    31013096        }
    3102         else                            // dtlb miss
     3097        else // dtlb miss
    31033098        {
    31043099            bypass = r_dtlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
    31053100        }
    31063101
    3107         if ( not bypass )    // Try to read PTE1/PTD1 in dcache
    3108         {
    3109             pte_paddr = (((paddr_t)r_mmu_ptpr.read()) << (INDEX1_NBITS+2)) |
    3110                         ((((paddr_t)r_dcache_tlb_vaddr.read()) >> PAGE_M_NBITS) << 2);
     3102        if (not bypass) // Try to read PTE1/PTD1 in dcache
     3103        {
     3104            pte_paddr = (((paddr_t) r_mmu_ptpr.read()) << (INDEX1_NBITS + 2)) |
     3105                       ((((paddr_t) r_dcache_tlb_vaddr.read()) >> PAGE_M_NBITS) << 2);
    31113106            r_dcache_tlb_paddr = pte_paddr;
    31123107            r_dcache_fsm       = DCACHE_TLB_PTE1_GET;
    31133108        }
    3114         else                  // Try to read PTE2 in dcache
    3115         {
    3116             pte_paddr = (paddr_t)ptba << PAGE_K_NBITS |
    3117                         (paddr_t)(r_dcache_tlb_vaddr.read()&PTD_ID2_MASK)>>(PAGE_K_NBITS-3);
     3109        else // Try to read PTE2 in dcache
     3110        {
     3111            pte_paddr = (paddr_t) ptba << PAGE_K_NBITS |
     3112                        (paddr_t) (r_dcache_tlb_vaddr.read() & PTD_ID2_MASK) >> (PAGE_K_NBITS - 3);
    31183113            r_dcache_tlb_paddr = pte_paddr;
    31193114            r_dcache_fsm       = DCACHE_TLB_PTE2_GET;
     
    31213116
    31223117#if DEBUG_DCACHE
    3123 if ( m_debug_activated )
    3124 {
    3125     if ( r_dcache_tlb_ins.read() )
    3126         std::cout << "  <PROC " << name() << " DCACHE_TLB_MISS> ITLB miss";
    3127     else
    3128         std::cout << "  <PROC " << name() << " DCACHE_TLB_MISS> DTLB miss";
    3129     std::cout << " / VADDR = " << std::hex << r_dcache_tlb_vaddr.read()
    3130               << " / ptpr  = " << (((paddr_t)r_mmu_ptpr.read()) << (INDEX1_NBITS+2))
    3131               << " / BYPASS = " << bypass
    3132               << " / PTE_ADR = " << pte_paddr << std::endl;
    3133 }
     3118        if (m_debug_activated)
     3119        {
     3120            if (r_dcache_tlb_ins.read())
     3121                std::cout << "  <PROC " << name() << " DCACHE_TLB_MISS> ITLB miss";
     3122            else
     3123                std::cout << "  <PROC " << name() << " DCACHE_TLB_MISS> DTLB miss";
     3124            std::cout << " / VADDR = " << std::hex << r_dcache_tlb_vaddr.read()
     3125                << " / ptpr  = " << (((paddr_t) r_mmu_ptpr.read()) << (INDEX1_NBITS + 2))
     3126                << " / BYPASS = " << bypass
     3127                << " / PTE_ADR = " << pte_paddr << std::endl;
     3128        }
    31343129#endif
    31353130
     
    31373132    }
    31383133    /////////////////////////
    3139     case DCACHE_TLB_PTE1_GET:   // try to read a PT1 entry in dcache
     3134    case DCACHE_TLB_PTE1_GET: // try to read a PT1 entry in dcache
    31403135    {
    31413136        // coherence clack request (from DSPIN CLACK)
    3142         if ( r_dcache_clack_req.read() )
     3137        if (r_dcache_clack_req.read())
    31433138        {
    31443139            r_dcache_fsm = DCACHE_CC_CHECK;
     
    31483143
    31493144        // coherence request (from CC_RECEIVE FSM)
    3150         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3145        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    31513146        {
    31523147            r_dcache_fsm = DCACHE_CC_CHECK;
     
    31553150        }
    31563151
    3157         uint32_t    entry;
    3158         size_t      way;
    3159         size_t      set;
    3160         size_t      word;
    3161         int         cache_state;
    3162         r_dcache.read( r_dcache_tlb_paddr.read(),
    3163                        &entry,
    3164                        &way,
    3165                        &set,
    3166                        &word,
    3167                        &cache_state );
    3168 
     3152        uint32_t entry;
     3153        size_t way;
     3154        size_t set;
     3155        size_t word;
     3156        int    cache_state;
     3157        r_dcache.read(r_dcache_tlb_paddr.read(),
     3158                      &entry,
     3159                      &way,
     3160                      &set,
     3161                      &word,
     3162                      &cache_state);
    31693163#ifdef INSTRUMENTATION
    3170 m_cpt_dcache_data_read++;
    3171 m_cpt_dcache_dir_read++;
    3172 #endif
    3173 
    3174         if (( cache_state == CACHE_SLOT_STATE_VALID_NCC ) or ( cache_state == CACHE_SLOT_STATE_VALID_CC ))
    3175         {
    3176             if ( not (entry & PTE_V_MASK) ) // unmapped
    3177             {
    3178                 if ( r_dcache_tlb_ins.read() )
     3164        m_cpt_dcache_data_read++;
     3165        m_cpt_dcache_dir_read++;
     3166#endif
     3167        if ((cache_state == CACHE_SLOT_STATE_VALID_NCC) or
     3168            (cache_state == CACHE_SLOT_STATE_VALID_CC))
     3169        {
     3170            if (not (entry & PTE_V_MASK)) // unmapped
     3171            {
     3172                if (r_dcache_tlb_ins.read())
    31793173                {
    31803174                    r_mmu_ietr             = MMU_READ_PT1_UNMAPPED;
     
    31853179                else
    31863180                {
    3187                     r_mmu_detr             = MMU_READ_PT1_UNMAPPED;
    3188                     r_mmu_dbvar            = r_dcache_tlb_vaddr.read();
    3189                     m_drsp.valid             = true;
    3190                     m_drsp.error             = true;
    3191                 }
    3192                 r_dcache_fsm          = DCACHE_IDLE;
     3181                    r_mmu_detr   = MMU_READ_PT1_UNMAPPED;
     3182                    r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
     3183                    m_drsp.valid = true;
     3184                    m_drsp.error = true;
     3185                }
     3186                r_dcache_fsm = DCACHE_IDLE;
    31933187
    31943188#if DEBUG_DCACHE
    3195 if ( m_debug_activated )
    3196 {
    3197     std::cout << "  <PROC " << name()
    3198               << " DCACHE_TLB_PTE1_GET> HIT in dcache, but unmapped"
    3199               << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
    3200               << std::dec << " / way = " << way
    3201               << std::dec << " / set = " << set
    3202               << std::dec << " / word = " << word
    3203               << std::hex << " / PTE1 = " << entry << std::endl;
    3204 }
    3205 #endif
    3206 
    3207             }
    3208             else if( entry & PTE_T_MASK )  //  PTD : me must access PT2
     3189                if (m_debug_activated)
     3190                {
     3191                    std::cout << "  <PROC " << name()
     3192                        << " DCACHE_TLB_PTE1_GET> HIT in dcache, but unmapped"
     3193                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     3194                        << std::dec << " / way = " << way
     3195                        << std::dec << " / set = " << set
     3196                        << std::dec << " / word = " << word
     3197                        << std::hex << " / PTE1 = " << entry << std::endl;
     3198                }
     3199#endif
     3200
     3201            }
     3202            else if (entry & PTE_T_MASK) //  PTD : me must access PT2
    32093203            {
    32103204                // mark the cache line ac containing a PTD
    3211                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_CONTAINS_PTD;
     3205                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_CONTAINS_PTD;
    32123206
    32133207                // register bypass
    3214                 if ( r_dcache_tlb_ins.read() )      // itlb
     3208                if (r_dcache_tlb_ins.read()) // itlb
    32153209                {
    32163210                    r_itlb.set_bypass(r_dcache_tlb_vaddr.read(),
    3217                                       entry & ((1 << (m_paddr_nbits-PAGE_K_NBITS)) - 1),
    3218                                       r_dcache_tlb_paddr.read() / (m_icache_words<<2) );
    3219                 }
    3220                 else                    // dtlb
     3211                                      entry & ((1 << (m_paddr_nbits - PAGE_K_NBITS)) - 1),
     3212                                      r_dcache_tlb_paddr.read() / (m_icache_words << 2));
     3213                }
     3214                else // dtlb
    32213215                {
    32223216                    r_dtlb.set_bypass(r_dcache_tlb_vaddr.read(),
    3223                                       entry & ((1 << (m_paddr_nbits-PAGE_K_NBITS)) - 1),
    3224                                       r_dcache_tlb_paddr.read() / (m_dcache_words<<2) );
     3217                                      entry & ((1 << (m_paddr_nbits - PAGE_K_NBITS)) - 1),
     3218                                      r_dcache_tlb_paddr.read() / (m_dcache_words << 2));
    32253219                }
    32263220                r_dcache_tlb_paddr =
    3227                     (paddr_t)(entry & ((1<<(m_paddr_nbits-PAGE_K_NBITS))-1)) << PAGE_K_NBITS |
    3228                     (paddr_t)(((r_dcache_tlb_vaddr.read() & PTD_ID2_MASK) >> PAGE_K_NBITS) << 3);
    3229                 r_dcache_fsm       = DCACHE_TLB_PTE2_GET;
     3221                    (paddr_t) (entry & ((1 << (m_paddr_nbits - PAGE_K_NBITS)) - 1)) << PAGE_K_NBITS |
     3222                    (paddr_t) (((r_dcache_tlb_vaddr.read() & PTD_ID2_MASK) >> PAGE_K_NBITS) << 3);
     3223                r_dcache_fsm = DCACHE_TLB_PTE2_GET;
    32303224
    32313225#if DEBUG_DCACHE
    3232 if ( m_debug_activated )
    3233 {
    3234     std::cout << "  <PROC " << name()
    3235               << " DCACHE_TLB_PTE1_GET> HIT in dcache"
    3236               << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
    3237               << std::dec << " / way = " << way
    3238               << std::dec << " / set = " << set
    3239               << std::dec << " / word = " << word
    3240               << std::hex << " / PTD = " << entry << std::endl;
    3241 }
    3242 #endif
    3243             }
    3244             else            //  PTE1 :  we must update the TLB
    3245             {
    3246                 r_dcache_content_state[m_icache_sets*way+set] = LINE_CACHE_IN_TLB;
     3226                if (m_debug_activated)
     3227                {
     3228                    std::cout << "  <PROC " << name()
     3229                        << " DCACHE_TLB_PTE1_GET> HIT in dcache"
     3230                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     3231                        << std::dec << " / way = " << way
     3232                        << std::dec << " / set = " << set
     3233                        << std::dec << " / word = " << word
     3234                        << std::hex << " / PTD = " << entry << std::endl;
     3235                }
     3236#endif
     3237            }
     3238            else //  PTE1 :  we must update the TLB
     3239            {
     3240                r_dcache_content_state[m_dcache_sets * way + set] = LINE_CACHE_IN_TLB;
    32473241                r_dcache_tlb_pte_flags  = entry;
    32483242                r_dcache_fsm            = DCACHE_TLB_PTE1_SELECT;
    32493243
    3250                 r_cas_islocal    = (cache_state == CACHE_SLOT_STATE_VALID_NCC);//do not check L2 if NCC: the CAS is necessarily a success
     3244                r_cas_islocal    = (cache_state == CACHE_SLOT_STATE_VALID_NCC); // do not check L2 if NCC: the CAS is necessarily a success
    32513245                r_cas_local_way  = way;
    32523246                r_cas_local_set  = set;
     
    32543248
    32553249#if DEBUG_DCACHE
    3256 if ( m_debug_activated )
    3257 {
    3258     std::cout << "  <PROC " << name()
    3259               << " DCACHE_TLB_PTE1_GET> HIT in dcache"
    3260               << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
    3261               << std::dec << " / way = " << way
    3262               << std::dec << " / set = " << set
    3263               << std::dec << " / word = " << word
    3264               << std::hex << " / PTE1 = " << entry << std::endl;
    3265 }
    3266 #endif
    3267             }
    3268         }
    3269         else if ( cache_state == CACHE_SLOT_STATE_ZOMBI ) // pending cleanup
     3250                if (m_debug_activated)
     3251                {
     3252                    std::cout << "  <PROC " << name()
     3253                        << " DCACHE_TLB_PTE1_GET> HIT in dcache"
     3254                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     3255                        << std::dec << " / way = " << way
     3256                        << std::dec << " / set = " << set
     3257                        << std::dec << " / word = " << word
     3258                        << std::hex << " / PTE1 = " << entry << std::endl;
     3259                }
     3260#endif
     3261            }
     3262        }
     3263        else if (cache_state == CACHE_SLOT_STATE_ZOMBI) // pending cleanup
    32703264        {
    32713265            // stalled until cleanup is acknowledged
    3272             r_dcache_fsm   = DCACHE_TLB_PTE1_GET;
    3273         }
    3274         else        // we must load the missing cache line in dcache
    3275         {
    3276             r_dcache_vci_miss_req  = true;
    3277             r_dcache_vci_paddr     = r_dcache_tlb_paddr.read();
    3278             r_dcache_save_paddr    = r_dcache_tlb_paddr.read();
    3279             r_dcache_miss_type     = PTE1_MISS;
    3280             r_dcache_fsm           = DCACHE_MISS_SELECT;
     3266            r_dcache_fsm = DCACHE_TLB_PTE1_GET;
     3267        }
     3268        else // we must load the missing cache line in dcache
     3269        {
     3270            r_dcache_vci_miss_req = true;
     3271            r_dcache_vci_paddr    = r_dcache_tlb_paddr.read();
     3272            r_dcache_save_paddr   = r_dcache_tlb_paddr.read();
     3273            r_dcache_miss_type    = PTE1_MISS;
     3274            r_dcache_fsm          = DCACHE_MISS_SELECT;
    32813275
    32823276#if DEBUG_DCACHE
    3283 if ( m_debug_activated )
    3284 {
    3285     std::cout << "  <PROC " << name()
    3286               << " DCACHE_TLB_PTE1_GET> MISS in dcache:"
    3287               << " PTE1 address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
    3288 }
     3277            if (m_debug_activated)
     3278            {
     3279                std::cout << "  <PROC " << name()
     3280                    << " DCACHE_TLB_PTE1_GET> MISS in dcache:"
     3281                    << " PTE1 address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
     3282            }
    32893283#endif
    32903284        }
     
    32923286    }
    32933287    ////////////////////////////
    3294     case DCACHE_TLB_PTE1_SELECT:   // select a slot for PTE1
     3288    case DCACHE_TLB_PTE1_SELECT: // select a slot for PTE1
    32953289    {
    32963290        size_t way;
    32973291        size_t set;
    32983292
    3299         if ( r_dcache_tlb_ins.read() )
    3300         {
    3301             r_itlb.select( r_dcache_tlb_vaddr.read(),
    3302                            true,  // PTE1
    3303                            &way,
    3304                            &set );
     3293        if (r_dcache_tlb_ins.read())
     3294        {
     3295            r_itlb.select(r_dcache_tlb_vaddr.read(),
     3296                          true,  // PTE1
     3297                          &way,
     3298                          &set);
    33053299#ifdef INSTRUMENTATION
    3306 m_cpt_ins_tlb_read++;
     3300            m_cpt_itlb_read++;
    33073301#endif
    33083302        }
    33093303        else
    33103304        {
    3311             r_dtlb.select( r_dcache_tlb_vaddr.read(),
    3312                            true,  // PTE1
    3313                            &way,
    3314                            &set );
     3305            r_dtlb.select(r_dcache_tlb_vaddr.read(),
     3306                          true,  // PTE1
     3307                          &way,
     3308                          &set);
    33153309#ifdef INSTRUMENTATION
    3316 m_cpt_data_tlb_read++;
     3310            m_cpt_dtlb_read++;
    33173311#endif
    33183312        }
     
    33223316
    33233317#if DEBUG_DCACHE
    3324 if ( m_debug_activated )
    3325 {
    3326     if ( r_dcache_tlb_ins.read() )
    3327         std::cout << "  <PROC " << name()
    3328                   << " DCACHE_TLB_PTE1_SELECT> Select a slot in ITLB:";
    3329     else
    3330         std::cout << "  <PROC " << name()
    3331                   << ".DCACHE_TLB_PTE1_SELECT> Select a slot in DTLB:";
    3332         std::cout << " way = " << std::dec << way
    3333                   << " / set = " << set << std::endl;
    3334 }
     3318        if (m_debug_activated)
     3319        {
     3320            if (r_dcache_tlb_ins.read())
     3321                std::cout << "  <PROC " << name()
     3322                    << " DCACHE_TLB_PTE1_SELECT> Select a slot in ITLB:";
     3323            else
     3324                std::cout << "  <PROC " << name()
     3325                    << ".DCACHE_TLB_PTE1_SELECT> Select a slot in DTLB:";
     3326            std::cout << " way = " << std::dec << way
     3327                << " / set = " << set << std::endl;
     3328        }
    33353329#endif
    33363330        break;
     
    33433337                                //   the coherence mechanism.
    33443338    {
    3345         paddr_t   nline    = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
    3346         uint32_t  pte      = r_dcache_tlb_pte_flags.read();
    3347         bool      pt_updt  = false;
    3348         bool      local    = true;
     3339        paddr_t nline = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words) + 2);
     3340        uint32_t pte  = r_dcache_tlb_pte_flags.read();
     3341        bool pt_updt  = false;
     3342        bool local    = true;
    33493343
    33503344        // We should compute the access locality:
     
    33553349        // As long as this computation is not done, all access are local.
    33563350
    3357         if ( local )                        // local access
    3358         {
    3359             if ( not ((pte & PTE_L_MASK) == PTE_L_MASK) ) // we must set the L bit
     3351        if (local) // local access
     3352        {
     3353            if (not ((pte & PTE_L_MASK) == PTE_L_MASK)) // we must set the L bit
    33603354            {
    33613355                pt_updt                = true;
    3362                 r_dcache_vci_cas_old    = pte;
    3363                 r_dcache_vci_cas_new    = pte | PTE_L_MASK;
     3356                r_dcache_vci_cas_old   = pte;
     3357                r_dcache_vci_cas_new   = pte | PTE_L_MASK;
    33643358                pte                    = pte | PTE_L_MASK;
    33653359                r_dcache_tlb_pte_flags = pte;
    33663360            }
    33673361        }
    3368         else                                // remote access
    3369         {
    3370             if ( not ((pte & PTE_R_MASK) == PTE_R_MASK) ) // we must set the R bit
     3362        else // remote access
     3363        {
     3364            if (not ((pte & PTE_R_MASK) == PTE_R_MASK)) // we must set the R bit
    33713365            {
    33723366                pt_updt                = true;
    3373                 r_dcache_vci_cas_old    = pte;
    3374                 r_dcache_vci_cas_new    = pte | PTE_R_MASK;
     3367                r_dcache_vci_cas_old   = pte;
     3368                r_dcache_vci_cas_new   = pte | PTE_R_MASK;
    33753369                pte                    = pte | PTE_R_MASK;
    33763370                r_dcache_tlb_pte_flags = pte;
     
    33783372        }
    33793373
    3380         if ( not pt_updt )                  // update TLB and return
    3381         {
    3382             if ( r_dcache_tlb_ins.read() )
    3383             {
    3384                 r_itlb.write( true,    // 2M page
    3385                               pte,
    3386                               0,        // argument unused for a PTE1
    3387                               r_dcache_tlb_vaddr.read(),
    3388                               r_dcache_tlb_way.read(),
    3389                               r_dcache_tlb_set.read(),
    3390                               nline );
     3374        if (not pt_updt) // update TLB and return
     3375        {
     3376            if (r_dcache_tlb_ins.read())
     3377            {
     3378                r_itlb.write(true, // 2M page
     3379                             pte,
     3380                             0, // argument unused for a PTE1
     3381                             r_dcache_tlb_vaddr.read(),
     3382                             r_dcache_tlb_way.read(),
     3383                             r_dcache_tlb_set.read(),
     3384                             nline);
    33913385#ifdef INSTRUMENTATION
    3392 m_cpt_ins_tlb_update_acc++;
     3386                m_cpt_itlb_write++;
    33933387#endif
    33943388
    33953389#if DEBUG_DCACHE
    3396 if ( m_debug_activated )
    3397 {
    3398     std::cout << "  <PROC " << name()
    3399               << " DCACHE_TLB_PTE1_UPDT> write PTE1 in ITLB"
    3400               << " / set = " << std::dec << r_dcache_tlb_set.read()
    3401               << " / way = " << r_dcache_tlb_way.read() << std::endl;
    3402     r_itlb.printTrace();
    3403 }
     3390                if (m_debug_activated)
     3391                {
     3392                    std::cout << "  <PROC " << name()
     3393                        << " DCACHE_TLB_PTE1_UPDT> write PTE1 in ITLB"
     3394                        << " / set = " << std::dec << r_dcache_tlb_set.read()
     3395                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
     3396                    r_itlb.printTrace();
     3397                }
    34043398#endif
    34053399            }
    34063400            else
    34073401            {
    3408                 r_dtlb.write( true,    // 2M page
    3409                               pte,
    3410                               0,        // argument unused for a PTE1
    3411                               r_dcache_tlb_vaddr.read(),
    3412                               r_dcache_tlb_way.read(),
    3413                               r_dcache_tlb_set.read(),
    3414                               nline );
     3402                r_dtlb.write(true, // 2M page
     3403                             pte,
     3404                             0, // argument unused for a PTE1
     3405                             r_dcache_tlb_vaddr.read(),
     3406                             r_dcache_tlb_way.read(),
     3407                             r_dcache_tlb_set.read(),
     3408                             nline);
    34153409#ifdef INSTRUMENTATION
    3416 m_cpt_data_tlb_update_acc++;
     3410                m_cpt_dtlb_write++;
    34173411#endif
    34183412
    34193413#if DEBUG_DCACHE
    3420 if ( m_debug_activated )
    3421 {
    3422     std::cout << "  <PROC " << name()
    3423               << " DCACHE_TLB_PTE1_UPDT> write PTE1 in DTLB"
    3424               << " / set = " << std::dec << r_dcache_tlb_set.read()
    3425               << " / way = " << r_dcache_tlb_way.read() << std::endl;
    3426     r_dtlb.printTrace();
    3427 }
     3414                if (m_debug_activated)
     3415                {
     3416                    std::cout << "  <PROC " << name()
     3417                        << " DCACHE_TLB_PTE1_UPDT> write PTE1 in DTLB"
     3418                        << " / set = " << std::dec << r_dcache_tlb_set.read()
     3419                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
     3420                    r_dtlb.printTrace();
     3421                }
    34283422#endif
    34293423            }
     
    34353429
    34363430#if DEBUG_DCACHE
    3437 if ( m_debug_activated )
    3438 {
    3439     std::cout << "  <PROC " << name()
    3440               << " DCACHE_TLB_PTE1_UPDT> L/R bit update required"
    3441               << std::endl;
    3442 }
     3431            if (m_debug_activated)
     3432            {
     3433                std::cout << "  <PROC " << name()
     3434                    << " DCACHE_TLB_PTE1_UPDT> L/R bit update required"
     3435                    << std::endl;
     3436            }
    34433437#endif
    34443438        }
     
    34463440    }
    34473441    /////////////////////////
    3448     case DCACHE_TLB_PTE2_GET:   // Try to get a PTE2 (64 bits) in the dcache
     3442    case DCACHE_TLB_PTE2_GET: // Try to get a PTE2 (64 bits) in the dcache
    34493443    {
    34503444        // coherence clack request (from DSPIN CLACK)
    3451         if ( r_dcache_clack_req.read() )
     3445        if (r_dcache_clack_req.read())
    34523446        {
    34533447            r_dcache_fsm = DCACHE_CC_CHECK;
     
    34573451
    34583452        // coherence request (from CC_RECEIVE FSM)
    3459         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3453        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    34603454        {
    34613455            r_dcache_fsm = DCACHE_CC_CHECK;
     
    34643458        }
    34653459
    3466         uint32_t    pte_flags     = 0;
    3467         uint32_t    pte_ppn       = 0;
    3468         size_t      way           = 0;
    3469         size_t      set           = 0;
    3470         size_t      word          = 0;
    3471         int         cache_state  = 0;
    3472 
    3473         r_dcache.read( r_dcache_tlb_paddr.read(),
    3474                        &pte_flags,
    3475                        &pte_ppn,
    3476                        &way,
    3477                        &set,
    3478                        &word,
    3479                        &cache_state );
     3460        uint32_t pte_flags   = 0;
     3461        uint32_t pte_ppn     = 0;
     3462        size_t   way         = 0;
     3463        size_t   set         = 0;
     3464        size_t   word        = 0;
     3465        int      cache_state = 0;
     3466
     3467        r_dcache.read(r_dcache_tlb_paddr.read(),
     3468                      &pte_flags,
     3469                      &pte_ppn,
     3470                      &way,
     3471                      &set,
     3472                      &word,
     3473                      &cache_state);
    34803474#ifdef INSTRUMENTATION
    3481 m_cpt_dcache_data_read++;
    3482 m_cpt_dcache_dir_read++;
    3483 #endif
    3484         if ((cache_state == CACHE_SLOT_STATE_VALID_CC) or (cache_state == CACHE_SLOT_STATE_VALID_NCC))
    3485         {
    3486             if ( not (pte_flags & PTE_V_MASK) ) // unmapped
    3487             {
    3488                 if ( r_dcache_tlb_ins.read() )
     3475        m_cpt_dcache_data_read++;
     3476        m_cpt_dcache_dir_read++;
     3477#endif
     3478        if ((cache_state == CACHE_SLOT_STATE_VALID_CC) or
     3479            (cache_state == CACHE_SLOT_STATE_VALID_NCC))
     3480        {
     3481            if (not (pte_flags & PTE_V_MASK)) // unmapped
     3482            {
     3483                if (r_dcache_tlb_ins.read())
    34893484                {
    34903485                    r_mmu_ietr             = MMU_READ_PT2_UNMAPPED;
     
    34953490                else
    34963491                {
    3497                     r_mmu_detr             = MMU_READ_PT2_UNMAPPED;
    3498                     r_mmu_dbvar            = r_dcache_tlb_vaddr.read();
    3499                     m_drsp.valid           = true;
    3500                     m_drsp.error           = true;
    3501                 }
    3502                 r_dcache_fsm               = DCACHE_IDLE;
     3492                    r_mmu_detr   = MMU_READ_PT2_UNMAPPED;
     3493                    r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
     3494                    m_drsp.valid = true;
     3495                    m_drsp.error = true;
     3496                }
     3497                r_dcache_fsm = DCACHE_IDLE;
    35033498
    35043499#if DEBUG_DCACHE
    3505 if ( m_debug_activated )
    3506 {
    3507     std::cout << "  <PROC " << name()
    3508               << " DCACHE_TLB_PTE2_GET> HIT in dcache, but PTE unmapped"
    3509               << " PTE_FLAGS = " << std::hex << pte_flags
    3510               << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
    3511 }
    3512 #endif
    3513             }
    3514             else                // mapped : we must update the TLB
    3515             {
    3516                 r_dcache_content_state[m_dcache_sets*way+set] = LINE_CACHE_IN_TLB;
     3500                if (m_debug_activated)
     3501                {
     3502                    std::cout << "  <PROC " << name()
     3503                        << " DCACHE_TLB_PTE2_GET> HIT in dcache, but PTE unmapped"
     3504                        << " PTE_FLAGS = " << std::hex << pte_flags