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

RWT Commit : vci_cc_vcache_wrapper cosmetic

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
     3505                        << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
     3506                }
     3507#endif
     3508            }
     3509            else // mapped : we must update the TLB
     3510            {
     3511                r_dcache_content_state[m_dcache_sets * way + set] = LINE_CACHE_IN_TLB;
    35173512                r_dcache_tlb_pte_flags  = pte_flags;
    35183513                r_dcache_tlb_pte_ppn    = pte_ppn;
    35193514                r_dcache_fsm            = DCACHE_TLB_PTE2_SELECT;
    35203515
    3521                 r_cas_islocal    = (cache_state == CACHE_SLOT_STATE_VALID_NCC);//do not check L2 if NCC: the CAS is necessarily a success
     3516                r_cas_islocal    = (cache_state == CACHE_SLOT_STATE_VALID_NCC); // do not check L2 if NCC: the CAS is necessarily a success
    35223517                r_cas_local_way  = way;
    35233518                r_cas_local_set  = set;
    … …  
    35253520
    35263521#if DEBUG_DCACHE
    3527 if ( m_debug_activated )
    3528 {
    3529     std::cout << "  <PROC " << name()
    3530               << " DCACHE_TLB_PTE2_GET> HIT in dcache:"
    3531               << " PTE_FLAGS = " << std::hex << pte_flags
    3532               << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
    3533 }
     3522                if (m_debug_activated)
     3523                {
     3524                    std::cout << "  <PROC " << name()
     3525                        << " DCACHE_TLB_PTE2_GET> HIT in dcache:"
     3526                        << " PTE_FLAGS = " << std::hex << pte_flags
     3527                        << " PTE_PPN = " << std::hex << pte_ppn << std::endl;
     3528                }
    35343529#endif
    35353530             }
    35363531        }
    3537         else if ( cache_state == CACHE_SLOT_STATE_ZOMBI ) // pending cleanup
     3532        else if (cache_state == CACHE_SLOT_STATE_ZOMBI) // pending cleanup
    35383533        {
    35393534            // stalled until cleanup is acknowledged
    … …  
    35413536
    35423537#if DEBUG_DCACHE
    3543 if ( m_debug_activated )
    3544 {
    3545     std::cout << "  <PROC " << name()
    3546               << " DCACHE_TLB_PTE2_GET> ZOMBI in dcache: waiting cleanup ack"
    3547               << std::endl;
    3548 }
     3538            if (m_debug_activated)
     3539            {
     3540                std::cout << "  <PROC " << name()
     3541                    << " DCACHE_TLB_PTE2_GET> ZOMBI in dcache: waiting cleanup ack"
     3542                    << std::endl;
     3543            }
    35493544#endif
    35503545        }
    … …  
    35583553
    35593554#if DEBUG_DCACHE
    3560 if ( m_debug_activated )
    3561 {
    3562     std::cout << "  <PROC " << name()
    3563               << " DCACHE_TLB_PTE2_GET> MISS in dcache:"
    3564               << " PTE address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
    3565 }
     3555            if (m_debug_activated)
     3556            {
     3557                std::cout << "  <PROC " << name()
     3558                    << " DCACHE_TLB_PTE2_GET> MISS in dcache:"
     3559                    << " PTE address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
     3560            }
    35663561#endif
    35673562        }
    … …  
    35743569        size_t set;
    35753570
    3576         if ( r_dcache_tlb_ins.read() )
    3577         {
    3578             r_itlb.select( r_dcache_tlb_vaddr.read(),
    3579                            false,  // PTE2
    3580                            &way,
    3581                            &set );
     3571        if (r_dcache_tlb_ins.read())
     3572        {
     3573            r_itlb.select(r_dcache_tlb_vaddr.read(),
     3574                          false, // PTE2
     3575                          &way,
     3576                          &set);
    35823577#ifdef INSTRUMENTATION
    3583 m_cpt_ins_tlb_read++;
     3578            m_cpt_itlb_read++;
    35843579#endif
    35853580        }
    35863581        else
    35873582        {
    3588             r_dtlb.select( r_dcache_tlb_vaddr.read(),
    3589                            false,  // PTE2
    3590                            &way,
    3591                            &set );
     3583            r_dtlb.select(r_dcache_tlb_vaddr.read(),
     3584                          false, // PTE2
     3585                          &way,
     3586                          &set);
    35923587#ifdef INSTRUMENTATION
    3593 m_cpt_data_tlb_read++;
     3588            m_cpt_dtlb_read++;
    35943589#endif
    35953590        }
    35963591
    35973592#if DEBUG_DCACHE
    3598 if ( m_debug_activated )
    3599 {
    3600     if ( r_dcache_tlb_ins.read() )
    3601         std::cout << "  <PROC " << name()
    3602                   << " DCACHE_TLB_PTE2_SELECT> Select a slot in ITLB:";
    3603     else
    3604         std::cout << "  <PROC " << name()
    3605                   << " DCACHE_TLB_PTE2_SELECT> Select a slot in DTLB:";
    3606         std::cout << " way = " << std::dec << way
    3607                   << " / set = " << set << std::endl;
    3608 }
     3593        if (m_debug_activated)
     3594        {
     3595            if (r_dcache_tlb_ins.read())
     3596                std::cout << "  <PROC " << name()
     3597                    << " DCACHE_TLB_PTE2_SELECT> Select a slot in ITLB:";
     3598            else
     3599                std::cout << "  <PROC " << name()
     3600                    << " DCACHE_TLB_PTE2_SELECT> Select a slot in DTLB:";
     3601            std::cout << " way = " << std::dec << way
     3602                << " / set = " << set << std::endl;
     3603        }
    36093604#endif
    36103605        r_dcache_tlb_way = way;
    … …  
    36203615                                //   the coherence mechanism.
    36213616    {
    3622         paddr_t         nline     = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
    3623         uint32_t        pte_flags = r_dcache_tlb_pte_flags.read();
    3624         uint32_t        pte_ppn   = r_dcache_tlb_pte_ppn.read();
    3625         bool            pt_updt   = false;
    3626         bool            local     = true;
     3617        paddr_t  nline     = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words) + 2);
     3618        uint32_t pte_flags = r_dcache_tlb_pte_flags.read();
     3619        uint32_t pte_ppn   = r_dcache_tlb_pte_ppn.read();
     3620        bool     pt_updt   = false;
     3621        bool     local     = true;
    36273622
    36283623        // We should compute the access locality:
    … …  
    36333628        // As long as this computation is not done, all access are local.
    36343629
    3635         if ( local )                        // local access
    3636         {
    3637             if ( not ((pte_flags & PTE_L_MASK) == PTE_L_MASK) ) // we must set the L bit
     3630        if (local) // local access
     3631        {
     3632            if (not ((pte_flags & PTE_L_MASK) == PTE_L_MASK)) // we must set the L bit
    36383633            {
    36393634                pt_updt                = true;
    … …  
    36463641        else                                                    // remote access
    36473642        {
    3648             if ( not ((pte_flags & PTE_R_MASK) == PTE_R_MASK) ) // we must set the R bit
     3643            if (not ((pte_flags & PTE_R_MASK) == PTE_R_MASK)) // we must set the R bit
    36493644            {
    36503645                pt_updt                = true;
    … …  
    36563651        }
    36573652
    3658         if ( not pt_updt )                      // update TLB
    3659         {
    3660             if ( r_dcache_tlb_ins.read() )
    3661             {
    3662                 r_itlb.write( false,    // 4K page
    3663                               pte_flags,
    3664                               pte_ppn,
    3665                               r_dcache_tlb_vaddr.read(),
    3666                               r_dcache_tlb_way.read(),
    3667                               r_dcache_tlb_set.read(),
    3668                               nline );
     3653        if (not pt_updt) // update TLB
     3654        {
     3655            if (r_dcache_tlb_ins.read())
     3656            {
     3657                r_itlb.write(false, // 4K page
     3658                             pte_flags,
     3659                             pte_ppn,
     3660                             r_dcache_tlb_vaddr.read(),
     3661                             r_dcache_tlb_way.read(),
     3662                             r_dcache_tlb_set.read(),
     3663                             nline);
    36693664#ifdef INSTRUMENTATION
    3670 m_cpt_ins_tlb_update_acc++;
     3665                m_cpt_itlb_write++;
    36713666#endif
    36723667
    36733668#if DEBUG_DCACHE
    3674 if ( m_debug_activated )
    3675 {
    3676     std::cout << "  <PROC " << name()
    3677               << " DCACHE_TLB_PTE2_UPDT> write PTE2 in ITLB"
    3678               << " / set = " << std::dec << r_dcache_tlb_set.read()
    3679               << " / way = " << r_dcache_tlb_way.read() << std::endl;
    3680     r_itlb.printTrace();
    3681 }
     3669                if (m_debug_activated)
     3670                {
     3671                    std::cout << "  <PROC " << name()
     3672                        << " DCACHE_TLB_PTE2_UPDT> write PTE2 in ITLB"
     3673                        << " / set = " << std::dec << r_dcache_tlb_set.read()
     3674                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
     3675                    r_itlb.printTrace();
     3676                }
    36823677#endif
    36833678            }
    36843679            else
    36853680            {
    3686                 r_dtlb.write( false,    // 4K page
    3687                               pte_flags,
    3688                               pte_ppn,
    3689                               r_dcache_tlb_vaddr.read(),
    3690                               r_dcache_tlb_way.read(),
    3691                               r_dcache_tlb_set.read(),
    3692                               nline );
     3681                r_dtlb.write(false, // 4K page
     3682                             pte_flags,
     3683                             pte_ppn,
     3684                             r_dcache_tlb_vaddr.read(),
     3685                             r_dcache_tlb_way.read(),
     3686                             r_dcache_tlb_set.read(),
     3687                             nline);
    36933688#ifdef INSTRUMENTATION
    3694 m_cpt_data_tlb_update_acc++;
     3689                m_cpt_dtlb_write++;
    36953690#endif
    36963691
    36973692#if DEBUG_DCACHE
    3698 if ( m_debug_activated )
    3699 {
    3700     std::cout << "  <PROC " << name()
    3701               << " DCACHE_TLB_PTE2_UPDT> write PTE2 in DTLB"
    3702               << " / set = " << std::dec << r_dcache_tlb_set.read()
    3703               << " / way = " << r_dcache_tlb_way.read() << std::endl;
    3704     r_dtlb.printTrace();
    3705 }
     3693                if (m_debug_activated)
     3694                {
     3695                    std::cout << "  <PROC " << name()
     3696                        << " DCACHE_TLB_PTE2_UPDT> write PTE2 in DTLB"
     3697                        << " / set = " << std::dec << r_dcache_tlb_set.read()
     3698                        << " / way = " << r_dcache_tlb_way.read() << std::endl;
     3699                    r_dtlb.printTrace();
     3700                }
    37063701#endif
    37073702
    … …  
    37143709
    37153710#if DEBUG_DCACHE
    3716 if ( m_debug_activated )
    3717 {
    3718     std::cout << "  <PROC " << name()
    3719               << " DCACHE_TLB_PTE2_UPDT> L/R bit update required" << std::endl;
    3720 }
     3711            if (m_debug_activated)
     3712            {
     3713                std::cout << "  <PROC " << name()
     3714                    << " DCACHE_TLB_PTE2_UPDT> L/R bit update required" << std::endl;
     3715            }
    37213716#endif
    37223717        }
    … …  
    37293724        uint32_t set  = r_cas_local_set.read();
    37303725        uint32_t word = r_cas_local_word.read();
    3731         paddr_t nline = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
     3726        paddr_t nline = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words) + 2);
    37323727#if DEBUG_DCACHE
    3733 if ( m_debug_activated )
    3734 {
    3735     std::cout << "  <PROC " << name()
    3736               << " DCACHE_TLB_LR_UPDT> Update dcache: (L/R) bit" << std::endl;
    3737 }
     3728        if (m_debug_activated)
     3729        {
     3730            std::cout << "  <PROC " << name()
     3731                << " DCACHE_TLB_LR_UPDT> Update dcache: (L/R) bit" << std::endl;
     3732        }
    37383733#endif
    37393734
    … …  
    37443739                           word,
    37453740                           r_dcache_vci_cas_new.read());
    3746             //compteur dirty
    3747             r_dcache_dirty_word[(way*m_dcache_sets +set)*m_dcache_words+word] = 1;
    3748 
    3749             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    3750             {
    3751                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    3752                 r_dcache_tlb_inval_line  = nline;
    3753                 r_dcache_tlb_inval_set   = 0;
    3754                 r_dcache_fsm_scan_save   = DCACHE_TLB_RETURN;
    3755                 r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     3741
     3742            // stats dirty words
     3743            r_dcache_dirty_word[(way * m_dcache_sets + set) * m_dcache_words + word] = 1;
     3744
     3745            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
     3746            {
     3747                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
     3748                r_dcache_tlb_inval_line = nline;
     3749                r_dcache_tlb_inval_set  = 0;
     3750                r_dcache_fsm_scan_save  = DCACHE_TLB_RETURN;
     3751                r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
    37563752                break;
    37573753            }
    37583754
    3759             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     3755            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
    37603756            {
    37613757                r_itlb.reset();
    … …  
    37643760
    37653761#if DEBUG_DCACHE
    3766                 if ( m_debug_activated )
     3762                if (m_debug_activated)
    37673763                {
    37683764                    std::cout << "  <PROC " << name()
    … …  
    37773773        {
    37783774            // r_dcache_vci_cas_old & r_dcache_vci_cas_new registers are already set
    3779           r_dcache_vci_paddr = r_dcache_tlb_paddr.read();
     3775            r_dcache_vci_paddr = r_dcache_tlb_paddr.read();
    37803776
    37813777            // checking llsc reservation buffer
    3782             if ( r_dcache_llsc_paddr.read() == r_dcache_tlb_paddr.read() )
     3778            if (r_dcache_llsc_paddr.read() == r_dcache_tlb_paddr.read())
    37833779                r_dcache_llsc_valid = false;
    37843780
    … …  
    38003796    {
    38013797        // coherence clack request (from DSPIN CLACK)
    3802         if ( r_dcache_clack_req.read() )
     3798        if (r_dcache_clack_req.read())
    38033799        {
    38043800            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38083804
    38093805        // coherence request (from CC_RECEIVE FSM)
    3810         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3806        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38113807        {
    38123808            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38153811        }
    38163812
    3817         if ( r_vci_rsp_data_error.read() ) // bus error
     3813        if (r_vci_rsp_data_error.read()) // bus error
    38183814        {
    38193815            std::cout << "BUS ERROR in DCACHE_TLB_LR_WAIT state" << std::endl;
    … …  
    38213817            exit(0);
    38223818        }
    3823        else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
     3819       else if (r_vci_rsp_fifo_dcache.rok()) // response available
    38243820       {
    38253821#if DEBUG_DCACHE
    3826 if ( m_debug_activated )
    3827 {
    3828     std::cout << "  <PROC " << name()
    3829               << " DCACHE_TLB_LR_WAIT> SC response received" << std::endl;
    3830 }
     3822           if (m_debug_activated)
     3823           {
     3824               std::cout << "  <PROC " << name()
     3825                   << " DCACHE_TLB_LR_WAIT> SC response received" << std::endl;
     3826           }
    38313827#endif
    38323828            vci_rsp_fifo_dcache_get = true;
    3833             r_dcache_fsm            = DCACHE_TLB_RETURN;
     3829            r_dcache_fsm = DCACHE_TLB_RETURN;
    38343830        }
    38353831        break;
    38363832    }
    38373833    ///////////////////////
    3838     case DCACHE_TLB_RETURN:    // return to caller depending on tlb miss type
     3834    case DCACHE_TLB_RETURN:  // return to caller depending on tlb miss type
    38393835    {
    38403836#if DEBUG_DCACHE
    3841 if ( m_debug_activated )
    3842 {
    3843     std::cout << "  <PROC " << name()
    3844               << " DCACHE_TLB_RETURN> TLB MISS completed" << std::endl;
    3845 }
    3846 #endif
    3847         if ( r_dcache_tlb_ins.read() ) r_icache_tlb_miss_req = false;
     3837        if (m_debug_activated)
     3838        {
     3839            std::cout << "  <PROC " << name()
     3840                << " DCACHE_TLB_RETURN> TLB MISS completed" << std::endl;
     3841        }
     3842#endif
     3843        if (r_dcache_tlb_ins.read()) r_icache_tlb_miss_req = false;
    38483844        r_dcache_fsm = DCACHE_IDLE;
    38493845        break;
    … …  
    38543850                                // Caution : the itlb miss requests must be taken
    38553851                                // to avoid dead-lock in case of simultaneous ITLB miss
     3852                                // Caution : the clack and cc requests must be taken
     3853                                // to avoid dead-lock
    38563854    {
    38573855        // coherence clack request (from DSPIN CLACK)
    3858         if ( r_dcache_clack_req.read() )
     3856        if (r_dcache_clack_req.read())
    38593857        {
    38603858            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38643862
    38653863        // coherence request (from CC_RECEIVE FSM)
    3866         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3864        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38673865        {
    38683866            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38723870
    38733871        // itlb miss request
    3874         if ( r_icache_tlb_miss_req.read() )
    3875         {
    3876             r_dcache_tlb_ins    = true;
    3877             r_dcache_tlb_vaddr  = r_icache_vaddr_save.read();
    3878             r_dcache_fsm        = DCACHE_TLB_MISS;
    3879             break;
    3880         }
    3881 
    3882         if ( not r_dcache_xtn_req.read() )
     3872        if (r_icache_tlb_miss_req.read())
     3873        {
     3874            r_dcache_tlb_ins   = true;
     3875            r_dcache_tlb_vaddr = r_icache_vaddr_save.read();
     3876            r_dcache_fsm       = DCACHE_TLB_MISS;
     3877            break;
     3878        }
     3879
     3880        if (not r_dcache_xtn_req.read())
    38833881        {
    38843882            r_dtlb.flush();
    … …  
    38903888    }
    38913889    /////////////////////
    3892     case DCACHE_XTN_SYNC:       // waiting until write buffer empty
    3893                                 // The coherence request must be taken
    3894                                 // as there is a risk of dead-lock
     3890    case DCACHE_XTN_SYNC:  // waiting until write buffer empty
     3891                           // The coherence request must be taken
     3892                           // as there is a risk of dead-lock
    38953893    {
    38963894        // coherence clack request (from DSPIN CLACK)
    3897         if ( r_dcache_clack_req.read() )
     3895        if (r_dcache_clack_req.read())
    38983896        {
    38993897            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39033901
    39043902        // coherence request (from CC_RECEIVE FSM)
    3905         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3903        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    39063904        {
    39073905            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39103908        }
    39113909
    3912         if ( r_wbuf.empty() )
    3913         {
    3914             m_drsp.valid   = true;
     3910        if (r_wbuf.empty())
     3911        {
     3912            m_drsp.valid = true;
    39153913            r_dcache_fsm = DCACHE_IDLE;
    39163914        }
    … …  
    39263924    {
    39273925        // coherence clack request (from DSPIN CLACK)
    3928         if ( r_dcache_clack_req.read() )
     3926        if (r_dcache_clack_req.read())
    39293927        {
    39303928            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39343932
    39353933        // coherence request (from CC_RECEIVE FSM)
    3936         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3934        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    39373935        {
    39383936            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39423940
    39433941        // itlb miss request
    3944         if ( r_icache_tlb_miss_req.read() )
    3945         {
    3946             r_dcache_tlb_ins    = true;
    3947             r_dcache_tlb_vaddr  = r_icache_vaddr_save.read();
    3948             r_dcache_fsm        = DCACHE_TLB_MISS;
     3942        if (r_icache_tlb_miss_req.read())
     3943        {
     3944            r_dcache_tlb_ins   = true;
     3945            r_dcache_tlb_vaddr = r_icache_vaddr_save.read();
     3946            r_dcache_fsm       = DCACHE_TLB_MISS;
    39493947            break;
    39503948        }
    39513949
    39523950        // test if XTN request to icache completed
    3953         if ( not r_dcache_xtn_req.read() )
     3951        if (not r_dcache_xtn_req.read())
    39543952        {
    39553953            r_dcache_fsm = DCACHE_IDLE;
    … …  
    39693967    {
    39703968        // coherence clack request (from DSPIN CLACK)
    3971         if ( r_dcache_clack_req.read() )
     3969        if (r_dcache_clack_req.read())
    39723970        {
    39733971            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39773975
    39783976        // coherence request (from CC_RECEIVE FSM)
    3979         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3977        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    39803978        {
    39813979            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39843982        }
    39853983
    3986         if ( not r_dcache_cc_send_req.read() ) // blocked until previous cc_send request is sent
    3987         {
    3988             int       state;
    3989             paddr_t   tag;
    3990             size_t    way = r_dcache_flush_count.read()/m_dcache_sets;
    3991             size_t    set = r_dcache_flush_count.read()%m_dcache_sets;
     3984        if (not r_dcache_cc_send_req.read()) // blocked until previous cc_send request is sent
     3985        {
     3986            int     state;
     3987            paddr_t tag;
     3988            size_t  way = r_dcache_flush_count.read()/m_dcache_sets;
     3989            size_t  set = r_dcache_flush_count.read()%m_dcache_sets;
    39923990
    39933991#ifdef INSTRUMENTATION
    3994 m_cpt_dcache_dir_read++;
    3995 #endif
    3996             r_dcache.read_dir( way,
    3997                                set,
    3998                                &tag,
    3999                                &state );
    4000 
    4001             if ( state == CACHE_SLOT_STATE_VALID_CC )        // inval required
     3992            m_cpt_dcache_dir_read++;
     3993#endif
     3994            r_dcache.read_dir(way,
     3995                              set,
     3996                              &tag,
     3997                              &state);
     3998
     3999            if (state == CACHE_SLOT_STATE_VALID_CC) // inval required
    40024000            {
    40034001                // request cleanup
    … …  
    40084006
    40094007                // goes to DCACHE_XTN_DC_FLUSH_GO to inval directory
    4010                 r_dcache_miss_way     = way;
    4011                 r_dcache_miss_set     = set;
     4008                r_dcache_miss_way = way;
     4009                r_dcache_miss_set = set;
     4010                r_dcache_fsm      = DCACHE_XTN_DC_FLUSH_GO;
    40124011                r_dcache_cc_cleanup_line_ncc = false;
    40134012                r_dcache_cc_cleanup_updt_data = false;
    4014                 r_dcache_fsm          = DCACHE_XTN_DC_FLUSH_GO;
    4015             }
    4016             else if ( state == CACHE_SLOT_STATE_VALID_NCC)
     4013            }
     4014            else if (state == CACHE_SLOT_STATE_VALID_NCC)
    40174015            {
    40184016                // request cleanup
    … …  
    40234021
    40244022                // goes to DCACHE_XTN_DC_FLUSH_GO to inval directory
    4025                 r_dcache_miss_way     = way;
    4026                 r_dcache_miss_set     = set;
     4023                r_dcache_miss_way = way;
     4024                r_dcache_miss_set = set;
    40274025                r_dcache_cc_cleanup_line_ncc = true;
    40284026
    4029                 if (r_dcache_content_state[m_dcache_sets*way+set] != LINE_CACHE_DATA_NOT_DIRTY)//Must send data in the cleanup
     4027                if (r_dcache_content_state[m_dcache_sets * way + set] != LINE_CACHE_DATA_NOT_DIRTY) // Must send data in the cleanup
    40304028                {
    40314029                    r_dcache_xtn_flush_addr_data = (tag * m_dcache_sets + set) * m_dcache_words * 4;
    40324030                    r_dcache_xtn_flush_data_cpt = 0;
    40334031                    r_dcache_cc_cleanup_updt_data = true;
    4034                     for (size_t w = 0; w< m_dcache_words; w++)
     4032                    for (size_t w = 0; w < m_dcache_words; w++)
    40354033                    {
    4036                         m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     4034                        m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets * way + set) * m_dcache_words + w];
    40374035                    }
    4038                     r_dcache_fsm          = DCACHE_XTN_DC_FLUSH_DATA;
     4036                    r_dcache_fsm = DCACHE_XTN_DC_FLUSH_DATA;
    40394037                }
    40404038                else
    40414039                {
    40424040                    r_dcache_cc_cleanup_updt_data = false;
    4043                     r_dcache_fsm          = DCACHE_XTN_DC_FLUSH_GO;
    4044                 }
    4045             }
    4046             else if ( r_dcache_flush_count.read() ==
    4047                       (m_dcache_sets*m_dcache_ways - 1) )  // last slot
     4041                    r_dcache_fsm = DCACHE_XTN_DC_FLUSH_GO;
     4042                }
     4043            }
     4044            else if (r_dcache_flush_count.read() ==
     4045                      (m_dcache_sets * m_dcache_ways - 1))  // last slot
    40484046            {
    40494047                r_dtlb.reset();
    … …  
    40544052
    40554053            // saturation counter
    4056             if ( r_dcache_flush_count.read() < (m_dcache_sets*m_dcache_ways - 1) )
     4054            if (r_dcache_flush_count.read() < (m_dcache_sets * m_dcache_ways - 1))
    40574055                r_dcache_flush_count = r_dcache_flush_count.read() + 1;
    40584056        }
    40594057        break;
    40604058    }
    4061 
    40624059    ////////////////////////////
    40634060    case DCACHE_XTN_DC_FLUSH_DATA:
    40644061    {
    40654062        uint32_t rdata;
    4066         size_t   way;
    4067         size_t   set;
    4068         size_t   word;
     4063        size_t way;
     4064        size_t set;
     4065        size_t word;
    40694066
    40704067        r_dcache.read_neutral(r_dcache_xtn_flush_addr_data.read(),
    … …  
    40734070                              &set,
    40744071                              &word);
    4075         if(r_cc_send_data_fifo.wok())
     4072
     4073        if (r_cc_send_data_fifo.wok())
    40764074        {
    40774075            r_dcache_xtn_flush_addr_data = r_dcache_xtn_flush_addr_data.read() + 4;
    40784076
    4079             cleanup_data_updt_fifo_dcache_put   = true;
    4080             cleanup_data_updt_fifo_dcache_data  = rdata;
     4077            cleanup_data_updt_fifo_dcache_put = true;
     4078            cleanup_data_updt_fifo_dcache_data = rdata;
    40814079
    40824080            r_dcache_xtn_flush_data_cpt = r_dcache_xtn_flush_data_cpt + 1;
    4083             if(r_dcache_xtn_flush_data_cpt.read() == (m_dcache_words - 1))
     4081            if (r_dcache_xtn_flush_data_cpt.read() == (m_dcache_words - 1))
    40844082            {
    40854083                r_dcache_xtn_flush_data_cpt = 0;
    … …  
    40894087        break;
    40904088    }
    4091 
    40924089    ////////////////////////////
    40934090    case DCACHE_XTN_DC_FLUSH_GO:    // Switch the cache slot to ZOMBI state
    … …  
    40984095        size_t set = r_dcache_miss_set.read();
    40994096
    4100         r_dcache_content_state[m_dcache_sets*way+set]  = LINE_CACHE_DATA_DIRTY;
     4097        r_dcache_content_state[m_dcache_sets * way + set]  = LINE_CACHE_DATA_DIRTY;
    41014098
    41024099#ifdef INSTRUMENTATION
    4103 m_cpt_dcache_dir_write++;
    4104 #endif
    4105 
    4106 
    4107 
    4108         r_dcache.write_dir( way,
    4109                             set,
    4110                             CACHE_SLOT_STATE_ZOMBI );
    4111 
    4112         if ( r_dcache_flush_count.read() ==
    4113              (m_dcache_sets*m_dcache_ways - 1) )  // last slot
     4100        m_cpt_dcache_dir_write++;
     4101#endif
     4102        r_dcache.write_dir(way,
     4103                           set,
     4104                           CACHE_SLOT_STATE_ZOMBI);
     4105
     4106        if (r_dcache_flush_count.read() ==
     4107             (m_dcache_sets * m_dcache_ways - 1))  // last slot
    41144108        {
    41154109            r_dtlb.reset();
    … …  
    41254119    }
    41264120    /////////////////////////
    4127     case DCACHE_XTN_DT_INVAL:   // handling processor XTN_DTLB_INVAL request
     4121    case DCACHE_XTN_DT_INVAL: // handling processor XTN_DTLB_INVAL request
    41284122    {
    41294123        r_dtlb.inval(r_dcache_save_wdata.read());
    4130         r_dcache_fsm        = DCACHE_IDLE;
    4131         m_drsp.valid          = true;
     4124        r_dcache_fsm = DCACHE_IDLE;
     4125        m_drsp.valid = true;
    41324126        break;
    41334127    }
    … …  
    41384132    {
    41394133        paddr_t paddr;
    4140         bool    hit;
    4141 
    4142         if ( r_mmu_mode.read() & DATA_TLB_MASK )    // dtlb activated
     4134        bool hit;
     4135
     4136        if (r_mmu_mode.read() & DATA_TLB_MASK) // dtlb activated
    41434137        {
    41444138
    41454139#ifdef INSTRUMENTATION
    4146 m_cpt_data_tlb_read++;
    4147 #endif
    4148             hit = r_dtlb.translate( r_dcache_save_wdata.read(),
    4149                                     &paddr );
    4150         }
    4151         else                        // dtlb not activated
     4140            m_cpt_dtlb_read++;
     4141#endif
     4142            hit = r_dtlb.translate(r_dcache_save_wdata.read(),
     4143                                   &paddr);
     4144        }
     4145        else // dtlb not activated
    41524146        {
    41534147            paddr = (paddr_t)r_dcache_save_wdata.read();
    41544148            if (vci_param::N > 32)
    41554149                paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
    4156             hit   = true;
    4157         }
    4158 
    4159         if ( hit )      // tlb hit
     4150            hit = true;
     4151        }
     4152
     4153        if (hit) // tlb hit
    41604154        {
    41614155            r_dcache_save_paddr = paddr;
    4162             r_dcache_fsm      = DCACHE_XTN_DC_INVAL_PA;
    4163         }
    4164         else            // tlb miss
     4156            r_dcache_fsm = DCACHE_XTN_DC_INVAL_PA;
     4157        }
     4158        else // tlb miss
    41654159        {
    41664160
    41674161#ifdef INSTRUMENTATION
    4168 m_cpt_data_tlb_miss++;
    4169 #endif
    4170             r_dcache_tlb_ins    = false;        // dtlb
    4171             r_dcache_tlb_vaddr  = r_dcache_save_wdata.read();
    4172             r_dcache_fsm        = DCACHE_TLB_MISS;
     4162            m_cpt_dtlb_miss++;
     4163#endif
     4164            r_dcache_tlb_ins   = false; // dtlb
     4165            r_dcache_tlb_vaddr = r_dcache_save_wdata.read();
     4166            r_dcache_fsm       = DCACHE_TLB_MISS;
    41734167        }
    41744168
    41754169#if DEBUG_DCACHE
    4176 if ( m_debug_activated )
    4177 {
    4178     std::cout << "  <PROC " << name()
    4179               << " DCACHE_XTN_DC_INVAL_VA> Compute physical address" << std::hex
    4180               << " / VADDR = " << r_dcache_save_wdata.read()
    4181               << " / PADDR = " << paddr << std::endl;
    4182 }
     4170        if (m_debug_activated)
     4171        {
     4172            std::cout << "  <PROC " << name()
     4173                << " DCACHE_XTN_DC_INVAL_VA> Compute physical address" << std::hex
     4174                << " / VADDR = " << r_dcache_save_wdata.read()
     4175                << " / PADDR = " << paddr << std::endl;
     4176        }
    41834177#endif
    41844178
    … …  
    41904184                                  // In this state we read dcache.
    41914185    {
    4192         size_t      way;
    4193         size_t      set;
    4194         size_t      word;
    4195         int         state;
     4186        size_t way;
     4187        size_t set;
     4188        size_t word;
     4189        int    state;
    41964190
    41974191#ifdef INSTRUMENTATION
    4198 m_cpt_dcache_dir_read++;
    4199 #endif
    4200         r_dcache.read_dir( r_dcache_save_paddr.read(),
    4201                            &state,
    4202                            &way,
    4203                            &set,
    4204                            &word );
    4205 
    4206         if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))  // inval to be done
     4192        m_cpt_dcache_dir_read++;
     4193#endif
     4194        r_dcache.read_dir(r_dcache_save_paddr.read(),
     4195                          &state,
     4196                          &way,
     4197                          &set,
     4198                          &word);
     4199
     4200        if ((state == CACHE_SLOT_STATE_VALID_CC) or
     4201            (state == CACHE_SLOT_STATE_VALID_NCC))  // inval to be done
    42074202        {
    42084203            r_dcache_xtn_way       = way;
    42094204            r_dcache_xtn_set       = set;
    42104205            r_dcache_xtn_state     = state;
    4211             r_dcache_xtn_data_addr = r_dcache_save_paddr.read()&~0x3F;
    4212 
    4213             if( (state == CACHE_SLOT_STATE_VALID_NCC) and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY) )
     4206            r_dcache_xtn_data_addr = r_dcache_save_paddr.read() & ~0x3F;
     4207
     4208            if ((state == CACHE_SLOT_STATE_VALID_NCC) and
     4209                (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_DATA_NOT_DIRTY))
    42144210            {
    42154211                m_cpt_cleanup_data_not_dirty ++;
    42164212            }
    42174213            r_dcache_fsm = DCACHE_XTN_DC_INVAL_GO;
    4218 
    4219         }
    4220         else        // miss : nothing to do
    4221         {
    4222             r_dcache_fsm      = DCACHE_IDLE;
    4223             m_drsp.valid      = true;
     4214        }
     4215        else // miss : nothing to do
     4216        {
     4217            r_dcache_fsm = DCACHE_IDLE;
     4218            m_drsp.valid = true;
    42244219        }
    42254220
    42264221#if DEBUG_DCACHE
    4227 if ( m_debug_activated )
    4228 {
    4229     std::cout << "  <PROC " << name()
    4230               << " DCACHE_XTN_DC_INVAL_PA> Test hit in dcache" << std::hex
    4231               << " / PADDR = " << r_dcache_save_paddr.read() << std::dec
    4232               << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))
    4233               << " / SET = " << set
    4234               << " / WAY = " << way << std::endl;
    4235     //r_dcache.printTrace();
    4236 }
     4222        if (m_debug_activated)
     4223        {
     4224            std::cout << "  <PROC " << name()
     4225                << " DCACHE_XTN_DC_INVAL_PA> Test hit in dcache" << std::hex
     4226                << " / PADDR = " << r_dcache_save_paddr.read() << std::dec
     4227                << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))
     4228                << " / SET = " << set
     4229                << " / WAY = " << way << std::endl;
     4230        }
    42374231#endif
    42384232        break;
    … …  
    42434237                                  // Test if itlb or dtlb inval is required
    42444238    {
    4245         if ( not r_dcache_cc_send_req.read() ) // blocked until previous cc_send request is sent
    4246         {
    4247             int     state      = r_dcache_xtn_state.read();
    4248             size_t  way        = r_dcache_xtn_way.read();
    4249             size_t  set        = r_dcache_xtn_set.read();
    4250             paddr_t nline      = r_dcache_save_paddr.read() / (m_dcache_words<<2);
     4239        if (not r_dcache_cc_send_req.read()) // blocked until previous cc_send request is sent
     4240        {
     4241            int state     = r_dcache_xtn_state.read();
     4242            size_t way    = r_dcache_xtn_way.read();
     4243            size_t set    = r_dcache_xtn_set.read();
     4244            paddr_t nline = r_dcache_save_paddr.read() / (m_dcache_words << 2);
    42514245
    42524246#ifdef INSTRUMENTATION
    4253 m_cpt_dcache_dir_write++;
    4254 #endif
    4255 
    4256             if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))// request cleanup
     4247            m_cpt_dcache_dir_write++;
     4248#endif
     4249            if ((state == CACHE_SLOT_STATE_VALID_CC) or
     4250                (state == CACHE_SLOT_STATE_VALID_NCC)) // request cleanup
    42574251            {
    42584252                r_dcache_cc_send_req   = true;
    … …  
    42634257                {
    42644258                    r_dcache_cc_cleanup_line_ncc = false;
    4265                     r_dcache.write_dir( way,
    4266                             set,
    4267                             CACHE_SLOT_STATE_ZOMBI );
     4259                    r_dcache.write_dir(way,
     4260                                       set,
     4261                                       CACHE_SLOT_STATE_ZOMBI);
    42684262                }
    42694263                else
    42704264                {
    42714265                    r_dcache_cc_cleanup_line_ncc = true;
    4272                     if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY)) //must send data
     4266                    if ((r_dcache_content_state[way * m_dcache_sets + set] != LINE_CACHE_DATA_NOT_DIRTY)) //must send data
    42734267                    {
    42744268                        r_dcache_cc_cleanup_updt_data = true;
    4275                         for (size_t w = 0; w< m_dcache_words; w++)
     4269                        for (size_t w = 0; w < m_dcache_words; w++)
    42764270                        {
    4277                             m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     4271                            m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets * way + set) * m_dcache_words + w];
    42784272                        }
    42794273                        r_dcache_fsm = DCACHE_XTN_DC_INVAL_DATA;
    … …  
    42834277                    {
    42844278                        r_dcache_cc_cleanup_updt_data = false;
    4285                         r_dcache.write_dir( way,
    4286                                             set,
    4287                                             CACHE_SLOT_STATE_ZOMBI );
     4279                        r_dcache.write_dir(way,
     4280                                           set,
     4281                                           CACHE_SLOT_STATE_ZOMBI);
    42884282                    }
    4289                     if( (state == CACHE_SLOT_STATE_VALID_NCC) and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY) )
     4283                    if ((state == CACHE_SLOT_STATE_VALID_NCC) and
     4284                        (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_DATA_NOT_DIRTY))
     4285                    {
    42904286                        m_cpt_cleanup_data_not_dirty ++;
     4287                    }
    42914288                }
    42924289            }
    42934290
    42944291            // possible itlb & dtlb invalidate
    4295             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
     4292            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
    42964293            {
    42974294                r_dcache_tlb_inval_line = nline;
    … …  
    42994296                r_dcache_fsm_scan_save  = DCACHE_XTN_DC_INVAL_END;
    43004297                r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
    4301                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    4302             }
    4303             else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD)
     4298                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
     4299            }
     4300            else if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
    43044301            {
    43054302                r_itlb.reset();
    43064303                r_dtlb.reset();
    4307                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     4304                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
    43084305                r_dcache_fsm = DCACHE_IDLE;
    43094306                m_drsp.valid = true;
    … …  
    43164313
    43174314#if DEBUG_DCACHE
    4318 if ( m_debug_activated )
    4319 {
    4320     std::cout << "  <PROC " << name()
    4321               << " DCACHE_XTN_DC_INVAL_GO> Actual dcache inval" << std::hex
    4322               << " / PADDR = " << r_dcache_save_paddr.read() << std::endl;
    4323 }
     4315            if (m_debug_activated)
     4316            {
     4317                std::cout << "  <PROC " << name()
     4318                    << " DCACHE_XTN_DC_INVAL_GO> Actual dcache inval" << std::hex
     4319                    << " / PADDR = " << r_dcache_save_paddr.read() << std::endl;
     4320            }
    43244321#endif
    43254322        }
    43264323        break;
    43274324    }
    4328 
    4329     /*RWT*/
    43304325    //////////////////////////////
    43314326    case DCACHE_XTN_DC_INVAL_DATA:
    43324327    {
    4333 
    43344328        uint32_t rdata;
    4335         size_t   way = 0; // To avoid gcc warning
    4336         size_t   set = 0; // To avoid gcc warning
    4337         size_t   word;
     4329        size_t way = 0; // To avoid gcc warning
     4330        size_t set = 0; // To avoid gcc warning
     4331        size_t word;
    43384332        r_dcache.read_neutral(r_dcache_xtn_data_addr.read(),
    43394333                              &rdata,
    … …  
    43414335                              &set,
    43424336                              &word);
    4343         if(r_cc_send_data_fifo.wok())
     4337        if (r_cc_send_data_fifo.wok())
    43444338        {
    43454339            r_dcache_xtn_data_addr = r_dcache_xtn_data_addr.read() + 4;
    43464340
    4347             cleanup_data_updt_fifo_dcache_put   = true;
    4348             cleanup_data_updt_fifo_dcache_data  = rdata;
     4341            cleanup_data_updt_fifo_dcache_put = true;
     4342            cleanup_data_updt_fifo_dcache_data = rdata;
    43494343
    43504344            r_dcache_xtn_data_cpt = r_dcache_xtn_data_cpt.read() + 1;
    4351             if(r_dcache_xtn_data_cpt.read() == (m_dcache_words - 1))
     4345            if (r_dcache_xtn_data_cpt.read() == (m_dcache_words - 1))
    43524346            {
    43534347                r_dcache_xtn_state = CACHE_SLOT_STATE_ZOMBI;
    43544348                r_dcache_xtn_data_cpt = 0;
    43554349                r_dcache_fsm = DCACHE_XTN_DC_INVAL_GO;
    4356                 r_dcache.write_dir( way,
    4357                                     set,
    4358                                     CACHE_SLOT_STATE_ZOMBI );
     4350                r_dcache.write_dir(way,
     4351                                   set,
     4352                                   CACHE_SLOT_STATE_ZOMBI);
    43594353            }
    43604354        }
    43614355        break;
    43624356    }
    4363 
    43644357    //////////////////////////////
    4365     case DCACHE_XTN_DC_INVAL_END:   // send response to processor XTN request
     4358    case DCACHE_XTN_DC_INVAL_END: // send response to processor XTN request
    43664359    {
    43674360        r_dcache_fsm = DCACHE_IDLE;
    … …  
    43774370                               // when a cleanup is required
    43784371    {
    4379         if ( m_dreq.valid) m_cost_data_miss_frz++;
     4372        if (m_dreq.valid) m_cost_data_miss_frz++;
    43804373
    43814374        // coherence clack request (from DSPIN CLACK)
    4382         if ( r_dcache_clack_req.read() )
     4375        if (r_dcache_clack_req.read())
    43834376        {
    43844377            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    43884381
    43894382        // coherence request (from CC_RECEIVE FSM)
    4390         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     4383        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    43914384        {
    43924385            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    43954388        }
    43964389
    4397             bool    found = false;
    4398             bool    cleanup = false;
    4399             size_t  way = 0;
    4400             size_t  set = 0;
    4401             paddr_t victim = 0;
    4402             int     state;
    4403             bool    s_cleanup_updt_data = false;
    4404             bool    s_cleanup_line_ncc = false;
     4390        bool    found = false;
     4391        bool    cleanup = false;
     4392        size_t  way = 0;
     4393        size_t  set = 0;
     4394        paddr_t victim = 0;
     4395        int     state;
     4396        bool    s_cleanup_updt_data = false;
     4397        bool    s_cleanup_line_ncc = false;
    44054398
    44064399#ifdef INSTRUMENTATION
    4407 m_cpt_dcache_dir_read++;
    4408 #endif
    4409             r_dcache.read_select( r_dcache_save_paddr.read(),
    4410                                   &victim,
    4411                                   &way,
    4412                                   &set,
    4413                                   &found,
    4414                                   &cleanup );
    4415             state = r_dcache.get_cache_state(way,set);
    4416 
    4417             if ( found )
    4418             {
    4419                 r_dcache_miss_way = way;
    4420                 r_dcache_miss_set = set;
    4421 
    4422                 if ( cleanup )
    4423                 {
    4424                     r_dcache_miss_clack   = true;
    4425                     r_dcache_fsm          = DCACHE_MISS_CLEAN;
    4426                     if( (state == CACHE_SLOT_STATE_VALID_NCC) )
     4400        m_cpt_dcache_dir_read++;
     4401#endif
     4402        r_dcache.read_select(r_dcache_save_paddr.read(),
     4403                             &victim,
     4404                             &way,
     4405                             &set,
     4406                             &found,
     4407                             &cleanup);
     4408        state = r_dcache.get_cache_state(way, set);
     4409
     4410        if (found)
     4411        {
     4412            r_dcache_miss_way = way;
     4413            r_dcache_miss_set = set;
     4414
     4415            if (cleanup)
     4416            {
     4417                r_dcache_miss_clack = true;
     4418                r_dcache_fsm = DCACHE_MISS_CLEAN;
     4419
     4420                if ((state == CACHE_SLOT_STATE_VALID_NCC))
     4421                {
     4422                    s_cleanup_line_ncc = true;
     4423                    r_dcache_miss_data_addr = (victim * m_dcache_words) * 4;
     4424                    if ((r_dcache_content_state[way * m_dcache_sets + set] != LINE_CACHE_DATA_NOT_DIRTY)) // must send data
    44274425                    {
    4428                         s_cleanup_line_ncc = true;
    4429                         r_dcache_miss_data_addr = (victim*m_dcache_words)*4;
    4430                         if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY))//must send data
     4426                        s_cleanup_updt_data = true;
     4427                        for (size_t w = 0; w < m_dcache_words; w++)
    44314428                        {
    4432                             s_cleanup_updt_data = true;
    4433                             for (size_t w = 0; w< m_dcache_words; w++)
    4434                             {
    4435                                 m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
    4436                             }
    4437                             r_dcache_fsm = DCACHE_MISS_DATA;
     4429                            m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets * way + set) * m_dcache_words + w];
    44384430                        }
    4439                         else
    4440                         {
    4441                             s_cleanup_updt_data = false;
    4442                         }
    4443 
    4444                         if (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY)
    4445                             m_cpt_cleanup_data_not_dirty ++;
     4431                        r_dcache_fsm = DCACHE_MISS_DATA;
    44464432                    }
    44474433                    else
    44484434                    {
    4449                         s_cleanup_line_ncc  = false;
    44504435                        s_cleanup_updt_data = false;
    44514436                    }
    44524437
    4453                     if( not r_dcache_cc_send_req.read() )
    4454                     {
    4455                         // request cleanup
    4456                         r_dcache_cc_send_req   = true;
    4457                         r_dcache_cc_send_nline = victim;
    4458                         r_dcache_cc_send_way   = way;
    4459                         r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
    4460                         r_dcache_cc_cleanup_updt_data = s_cleanup_updt_data;
    4461                         r_dcache_cc_cleanup_line_ncc  = s_cleanup_line_ncc;
    4462                     }
    4463                     else
    4464                     {
    4465                         r_dcache_cleanup_victim_nline = victim;
    4466                         r_dcache_cleanup_victim_req = true;
    4467                         r_dcache_cleanup_victim_updt_data = s_cleanup_updt_data;
    4468                         r_dcache_cleanup_victim_line_ncc = s_cleanup_line_ncc;
    4469                     }
     4438                    if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_DATA_NOT_DIRTY)
     4439                        m_cpt_cleanup_data_not_dirty ++;
    44704440                }
    44714441                else
    44724442                {
    4473                     r_dcache_fsm          = DCACHE_MISS_WAIT;
    4474                 }
     4443                    s_cleanup_line_ncc  = false;
     4444                    s_cleanup_updt_data = false;
     4445                }
     4446
     4447                if (not r_dcache_cc_send_req.read())
     4448                {
     4449                    // request cleanup
     4450                    r_dcache_cc_send_req   = true;
     4451                    r_dcache_cc_send_nline = victim;
     4452                    r_dcache_cc_send_way   = way;
     4453                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     4454                    r_dcache_cc_cleanup_updt_data = s_cleanup_updt_data;
     4455                    r_dcache_cc_cleanup_line_ncc  = s_cleanup_line_ncc;
     4456                }
     4457                else
     4458                {
     4459                    r_dcache_cleanup_victim_nline = victim;
     4460                    r_dcache_cleanup_victim_req = true;
     4461                    r_dcache_cleanup_victim_updt_data = s_cleanup_updt_data;
     4462                    r_dcache_cleanup_victim_line_ncc = s_cleanup_line_ncc;
     4463                }
     4464            }
     4465            else
     4466            {
     4467                r_dcache_fsm = DCACHE_MISS_WAIT;
     4468            }
    44754469
    44764470#if DEBUG_DCACHE
    4477 if ( m_debug_activated )
    4478 {
    4479     std::cout << "  <PROC " << name()
    4480               << " DCACHE_MISS_SELECT> Select a slot:" << std::dec
    4481               << " / WAY = "   << way
    4482               << " / SET = "   << set
    4483               << " / PADDR = " << std::hex << r_dcache_save_paddr.read();
    4484     if(cleanup) std::cout << " / VICTIM = " << (victim*m_dcache_words*4) << std::endl;
    4485     else        std::cout << std::endl;
    4486 }
    4487 #endif
    4488             } // end found
     4471            if (m_debug_activated)
     4472            {
     4473                std::cout << "  <PROC " << name()
     4474                    << " DCACHE_MISS_SELECT> Select a slot:" << std::dec
     4475                    << " / WAY = "   << way
     4476                    << " / SET = "   << set
     4477                    << " / PADDR = " << std::hex << r_dcache_save_paddr.read();
     4478                if (cleanup) std::cout << " / VICTIM = " << (victim * m_dcache_words * 4) << std::dec << std::endl;
     4479                else         std::cout << std::dec << std::endl;
     4480            }
     4481#endif
     4482        } // end found
    44894483        break;
    44904484    }
    … …  
    44974491        size_t word;
    44984492
    4499         if( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
     4493        if (r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read())
    45004494        {
    45014495            r_dcache_cc_send_req = true;
    … …  
    45134507                              &set,
    45144508                              &word);
    4515         if(r_cc_send_data_fifo.wok())
     4509        if (r_cc_send_data_fifo.wok())
    45164510        {
    45174511            r_dcache_miss_data_addr = r_dcache_miss_data_addr.read() + 4;
    45184512
    4519             cleanup_data_updt_fifo_dcache_put   = true;
    4520             cleanup_data_updt_fifo_dcache_data  = rdata;
     4513            cleanup_data_updt_fifo_dcache_put = true;
     4514            cleanup_data_updt_fifo_dcache_data = rdata;
    45214515
    45224516            r_dcache_miss_data_cpt = r_dcache_miss_data_cpt.read() + 1;
    4523             if (r_dcache_miss_data_cpt.read() == m_dcache_words-1 )
     4517            if (r_dcache_miss_data_cpt.read() == (m_dcache_words - 1))
    45244518            {
    45254519                r_dcache_miss_data_cpt = 0;
    … …  
    45344528                                // and possibly request itlb or dtlb invalidate
    45354529    {
    4536         if ( m_dreq.valid) m_cost_data_miss_frz++;
    4537 
    4538         size_t  way  = r_dcache_miss_way.read();
    4539         size_t  set  = r_dcache_miss_set.read();
     4530        if (m_dreq.valid) m_cost_data_miss_frz++;
     4531
     4532        size_t way = r_dcache_miss_way.read();
     4533        size_t set = r_dcache_miss_set.read();
    45404534
    45414535#ifdef INSTRUMENTATION
    4542 m_cpt_dcache_dir_read++;
    4543 #endif
    4544         r_dcache.write_dir( way,
    4545                             set,
    4546                             CACHE_SLOT_STATE_ZOMBI );
     4536        m_cpt_dcache_dir_read++;
     4537#endif
     4538        r_dcache.write_dir(way,
     4539                           set,
     4540                           CACHE_SLOT_STATE_ZOMBI);
    45474541#if DEBUG_DCACHE
    4548 if ( m_debug_activated )
    4549 {
    4550     std::cout << "  <PROC " << name()
    4551               << " DCACHE_MISS_CLEAN> Switch to ZOMBI state" << std::dec
    4552               << " / way = "   << way
    4553               << " / set = "   << set << std::endl;
    4554 }
     4542        if (m_debug_activated)
     4543        {
     4544            std::cout << "  <PROC " << name()
     4545                << " DCACHE_MISS_CLEAN> Switch to ZOMBI state" << std::dec
     4546                << " / way = "   << way
     4547                << " / set = "   << set << std::endl;
     4548        }
    45554549#endif
    45564550        // if selective itlb & dtlb invalidate are required
    45574551        // the miss response is not handled before invalidate completed
    4558         if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    4559         {
    4560             r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    4561             if( not r_dcache_cleanup_victim_req.read() )
    4562             {
     4552        if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
     4553        {
     4554            r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
     4555
     4556            if (not r_dcache_cleanup_victim_req.read())
    45634557                r_dcache_tlb_inval_line = r_dcache_cc_send_nline.read();
    4564             }
    45654558            else
    4566             {
    45674559                r_dcache_tlb_inval_line = r_dcache_cleanup_victim_nline.read();
    4568             }
    4569             r_dcache_tlb_inval_set   = 0;
    4570             r_dcache_fsm_scan_save   = DCACHE_MISS_WAIT;
    4571             r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    4572         }
    4573         else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     4560
     4561            r_dcache_tlb_inval_set = 0;
     4562            r_dcache_fsm_scan_save = DCACHE_MISS_WAIT;
     4563            r_dcache_fsm           = DCACHE_INVAL_TLB_SCAN;
     4564        }
     4565        else if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
    45744566        {
    45754567            r_itlb.reset();
    45764568            r_dtlb.reset();
    4577             r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     4569            r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
    45784570            r_dcache_fsm = DCACHE_MISS_WAIT;
    45794571        }
    … …  
    45894581                            // There is 5 types of error depending on the requester
    45904582    {
    4591         if ( m_dreq.valid) m_cost_data_miss_frz++;
    4592 
    4593         if( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
    4594         {
    4595             r_dcache_cc_send_req = true;
    4596             r_dcache_cc_send_type = CC_TYPE_CLEANUP;
    4597             r_dcache_cc_send_nline = r_dcache_cleanup_victim_nline.read();
     4583        if (m_dreq.valid) m_cost_data_miss_frz++;
     4584
     4585        // send cleanup victim request
     4586        if (r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read())
     4587        {
     4588            r_dcache_cc_send_req        = true;
     4589            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline.read();
     4590            r_dcache_cc_send_way        = r_dcache_miss_way.read();
     4591            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
    45984592            r_dcache_cleanup_victim_req = false;
    45994593            r_dcache_cc_cleanup_updt_data = r_dcache_cleanup_victim_updt_data.read();
    4600             r_dcache_cc_cleanup_line_ncc = r_dcache_cleanup_victim_line_ncc.read();
    4601             r_dcache_cc_send_way = r_dcache_miss_way;
     4594            r_dcache_cc_cleanup_line_ncc  = r_dcache_cleanup_victim_line_ncc.read();
    46024595        }
    46034596
    46044597        // coherence clack request (from DSPIN CLACK)
    4605         if ( r_dcache_clack_req.read() )
     4598        if (r_dcache_clack_req.read())
    46064599        {
    46074600            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    46114604
    46124605        // coherence request (from CC_RECEIVE FSM)
    4613         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() and not r_dcache_cleanup_victim_req.read() )
     4606        if (r_cc_receive_dcache_req.read() and
     4607            not r_dcache_cc_send_req.read() and
     4608            not r_dcache_cleanup_victim_req.read())
    46144609        {
    46154610            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    46184613        }
    46194614
    4620         if ( r_vci_rsp_data_error.read() ) // bus error
    4621         {
    4622             switch ( r_dcache_miss_type.read() )
     4615        if (r_vci_rsp_data_error.read()) // bus error
     4616        {
     4617            switch (r_dcache_miss_type.read())
    46234618            {
    46244619                case PROC_MISS:
    46254620                {
    4626                     r_mmu_detr            = MMU_READ_DATA_ILLEGAL_ACCESS;
    4627                     r_mmu_dbvar           = r_dcache_save_vaddr.read();
    4628                     m_drsp.valid            = true;
    4629                     m_drsp.error            = true;
    4630                     r_dcache_fsm          = DCACHE_IDLE;
     4621                    r_mmu_detr   = MMU_READ_DATA_ILLEGAL_ACCESS;
     4622                    r_mmu_dbvar  = r_dcache_save_vaddr.read();
     4623                    m_drsp.valid = true;
     4624                    m_drsp.error = true;
     4625                    r_dcache_fsm = DCACHE_IDLE;
    46314626                    break;
    46324627                }
    46334628                case PTE1_MISS:
    46344629                {
    4635                     if ( r_dcache_tlb_ins.read() )
     4630                    if (r_dcache_tlb_ins.read())
    46364631                    {
    4637                         r_mmu_ietr              = MMU_READ_PT1_ILLEGAL_ACCESS;
    4638                         r_mmu_ibvar             = r_dcache_tlb_vaddr.read();
    4639                         r_icache_tlb_miss_req   = false;
    4640                         r_icache_tlb_rsp_error  = true;
     4632                        r_mmu_ietr             = MMU_READ_PT1_ILLEGAL_ACCESS;
     4633                        r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
     4634                        r_icache_tlb_miss_req  = false;
     4635                        r_icache_tlb_rsp_error = true;
    46414636                    }
    46424637                    else
    46434638                    {
    4644                         r_mmu_detr              = MMU_READ_PT1_ILLEGAL_ACCESS;
    4645                         r_mmu_dbvar             = r_dcache_tlb_vaddr.read();
    4646                         m_drsp.valid              = true;
    4647                         m_drsp.error              = true;
     4639                        r_mmu_detr   = MMU_READ_PT1_ILLEGAL_ACCESS;
     4640                        r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
     4641                        m_drsp.valid = true;
     4642                        m_drsp.error = true;
    46484643                    }
    4649                     r_dcache_fsm                = DCACHE_IDLE;
     4644                    r_dcache_fsm = DCACHE_IDLE;
    46504645                    break;
    46514646                }
    46524647                case PTE2_MISS:
    46534648                {
    4654                     if ( r_dcache_tlb_ins.read() )
     4649                    if (r_dcache_tlb_ins.read())
    46554650                    {
    4656                         r_mmu_ietr              = MMU_READ_PT2_ILLEGAL_ACCESS;
    4657                         r_mmu_ibvar             = r_dcache_tlb_vaddr.read();
    4658                         r_icache_tlb_miss_req   = false;
    4659                         r_icache_tlb_rsp_error  = true;
     4651                        r_mmu_ietr             = MMU_READ_PT2_ILLEGAL_ACCESS;
     4652                        r_mmu_ibvar            = r_dcache_tlb_vaddr.read();
     4653                        r_icache_tlb_miss_req  = false;
     4654                        r_icache_tlb_rsp_error = true;
    46604655                    }
    46614656                    else
    46624657                    {
    4663                         r_mmu_detr              = MMU_READ_PT2_ILLEGAL_ACCESS;
    4664                         r_mmu_dbvar             = r_dcache_tlb_vaddr.read();
    4665                         m_drsp.valid              = true;
    4666                         m_drsp.error              = true;
     4658                        r_mmu_detr   = MMU_READ_PT2_ILLEGAL_ACCESS;
     4659                        r_mmu_dbvar  = r_dcache_tlb_vaddr.read();
     4660                        m_drsp.valid = true;
     4661                        m_drsp.error = true;
    46674662                    }
    4668                     r_dcache_fsm                = DCACHE_IDLE;
     4663                    r_dcache_fsm = DCACHE_IDLE;
    46694664                    break;
    46704665                }
    … …  
    46724667            r_vci_rsp_data_error = false;
    46734668        }
    4674         else if ( r_vci_rsp_fifo_dcache.rok() )    // valid response available
     4669        else if (r_vci_rsp_fifo_dcache.rok()) // valid response available
    46754670        {
    46764671            r_dcache_miss_word = 0;
    … …  
    46804675    }
    46814676    //////////////////////////
    4682     case DCACHE_MISS_DATA_UPDT:   // update the dcache (one word per cycle)
    4683     {
    4684         if ( m_dreq.valid) m_cost_data_miss_frz++;
    4685 
    4686         if ( r_vci_rsp_fifo_dcache.rok() && r_vci_rsp_fifo_rpktid.rok())  // one word available
     4677    case DCACHE_MISS_DATA_UPDT:  // update the dcache (one word per cycle)
     4678    {
     4679        if (m_dreq.valid) m_cost_data_miss_frz++;
     4680
     4681        if (r_vci_rsp_fifo_dcache.rok() and r_vci_rsp_fifo_rpktid.rok()) // one word available
    46874682        {
    46884683#ifdef INSTRUMENTATION
    4689 m_cpt_dcache_data_write++;
    4690 #endif
    4691                 r_dcache.write( r_dcache_miss_way.read(),
    4692                                 r_dcache_miss_set.read(),
    4693                                 r_dcache_miss_word.read(),
    4694                                 r_vci_rsp_fifo_dcache.read() );
     4684            m_cpt_dcache_data_write++;
     4685#endif
     4686            r_dcache.write(r_dcache_miss_way.read(),
     4687                           r_dcache_miss_set.read(),
     4688                           r_dcache_miss_word.read(),
     4689                           r_vci_rsp_fifo_dcache.read());
    46954690#if DEBUG_DCACHE
    4696 if ( m_debug_activated )
    4697 {
    4698     std::cout << "  <PROC " << name()
    4699               << " DCACHE_MISS_DATA_UPDT> Write one word:"
    4700               << " / DATA = "  << std::hex << r_vci_rsp_fifo_dcache.read()
    4701               << " / WAY = "   << std::dec << r_dcache_miss_way.read()
    4702               << " / SET = "   << r_dcache_miss_set.read()
    4703               << " / WORD = "  << r_dcache_miss_word.read() << std::endl;
    4704 }
     4691            if (m_debug_activated)
     4692            {
     4693                std::cout << "  <PROC " << name()
     4694                    << " DCACHE_MISS_DATA_UPDT> Write one word:"
     4695                    << " / DATA = "  << std::hex << r_vci_rsp_fifo_dcache.read()
     4696                    << " / WAY = "   << std::dec << r_dcache_miss_way.read()
     4697                    << " / SET = "   << r_dcache_miss_set.read()
     4698                    << " / WORD = "  << r_dcache_miss_word.read() << std::endl;
     4699            }
    47054700#endif
    47064701            vci_rsp_fifo_dcache_get = true;
    47074702
    4708             r_dcache_read_state = !r_vci_rsp_fifo_rpktid.read();//deduce the state (CC or NCC) from msb of pktid
     4703            r_dcache_read_state = not r_vci_rsp_fifo_rpktid.read(); //deduce the state (CC or NCC) from msb of pktid
    47094704            vci_rsp_fifo_rpktid_get = true;
    47104705
    4711 
    47124706            r_dcache_miss_word = r_dcache_miss_word.read() + 1;
    47134707
    4714             if ( r_dcache_miss_word.read() == (m_dcache_words-1) ) // last word
     4708            if (r_dcache_miss_word.read() == (m_dcache_words - 1)) // last word
    47154709            {
    47164710                r_dcache_fsm = DCACHE_MISS_DIR_UPDT;
    … …  
    47284722                                //   to ZOMBI state, and send a cleanup request.
    47294723    {
    4730         if ( m_dreq.valid) m_cost_data_miss_frz++;
    4731 
    4732         if( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
    4733         {
    4734             r_dcache_cc_send_req = true;
    4735             r_dcache_cc_send_type = CC_TYPE_CLEANUP;
    4736             r_dcache_cc_send_nline = r_dcache_cleanup_victim_nline.read();
     4724        if (m_dreq.valid) m_cost_data_miss_frz++;
     4725
     4726        // send cleanup victim request
     4727        if (r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read())
     4728        {
     4729            r_dcache_cc_send_req        = true;
     4730            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline.read();
     4731            r_dcache_cc_send_way        = r_dcache_miss_way.read();
     4732            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
    47374733            r_dcache_cleanup_victim_req = false;
    47384734            r_dcache_cc_cleanup_updt_data = r_dcache_cleanup_victim_updt_data.read();
    4739             r_dcache_cc_cleanup_line_ncc = r_dcache_cleanup_victim_line_ncc.read();
    4740             r_dcache_cc_send_way = r_dcache_miss_way;
     4735            r_dcache_cc_cleanup_line_ncc  = r_dcache_cleanup_victim_line_ncc.read();
    47414736        }
    47424737
    47434738        // coherence clack request (from DSPIN CLACK)
    4744         if ( r_dcache_clack_req.read() )
     4739        if (r_dcache_clack_req.read())
    47454740        {
    47464741            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    47504745
    47514746        // coherence request (from CC_RECEIVE FSM)
    4752         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() and not r_dcache_cleanup_victim_req.read() )
     4747        if (r_cc_receive_dcache_req.read() and
     4748            not r_dcache_cc_send_req.read() and
     4749            not r_dcache_cleanup_victim_req.read())
    47534750        {
    47544751            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    47574754        }
    47584755
    4759         if ( not r_dcache_miss_clack.read() )  // waiting cleanup acknowledge
    4760         {
    4761             if ( r_dcache_miss_inval.read() ) // switch slot to ZOMBI state, and new cleanup
    4762             {
    4763                 if ( not r_dcache_cc_send_req.read() ) // blocked until previous request sent
    4764                 {
    4765                     r_dcache_miss_inval     = false;
     4756        if (not r_dcache_miss_clack.read())  // waiting cleanup acknowledge
     4757        {
     4758            if (r_dcache_miss_inval.read()) // switch slot to ZOMBI state, and new cleanup
     4759            {
     4760                if (not r_dcache_cc_send_req.read()) // blocked until previous request sent
     4761                {
     4762                    r_dcache_miss_inval    = false;
    47664763                    // request cleanup
    47674764                    r_dcache_cc_send_req   = true;
    4768                     r_dcache_cc_send_nline = r_dcache_save_paddr.read()/(m_dcache_words<<2);
     4765                    r_dcache_cc_send_nline = r_dcache_save_paddr.read() / (m_dcache_words << 2);
    47694766                    r_dcache_cc_send_way   = r_dcache_miss_way.read();
    47704767                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
    4771                     r_dcache_cc_cleanup_updt_data = false; //the line is evicted at the very moment it arives, so it is not dirty
    4772                     r_dcache_cc_cleanup_line_ncc = !r_dcache_read_state.read();
     4768                    r_dcache_cc_cleanup_updt_data = false; // the line is evicted at the very moment it arives, so it is not dirty
     4769                    r_dcache_cc_cleanup_line_ncc  = !r_dcache_read_state.read();
    47734770
    47744771#ifdef INSTRUMENTATION
    4775 m_cpt_dcache_dir_write++;
     4772                    m_cpt_dcache_dir_write++;
    47764773#endif
    47774774                    r_dcache.write_dir( r_dcache_save_paddr.read(),
    … …  
    47804777                                        CACHE_SLOT_STATE_ZOMBI );
    47814778#if DEBUG_DCACHE
    4782 if ( m_debug_activated )
    4783 std::cout << "  <PROC " << name()
    4784           << " DCACHE_MISS_DIR_UPDT> Switch slot to ZOMBI state"
    4785           << " PADDR = " << std::hex << r_dcache_save_paddr.read()
    4786           << " / WAY = "   << std::dec << r_dcache_miss_way.read()
    4787           << " / SET = "   << r_dcache_miss_set.read() << std::endl;
     4779                    if (m_debug_activated)
     4780                        std::cout << "  <PROC " << name()
     4781                            << " DCACHE_MISS_DIR_UPDT> Switch slot to ZOMBI state"
     4782                            << " PADDR = " << std::hex << r_dcache_save_paddr.read()
     4783                            << " / WAY = "   << std::dec << r_dcache_miss_way.read()
     4784                            << " / SET = "   << r_dcache_miss_set.read() << std::endl;
    47884785#endif
    47894786                }
    … …  
    47954792
    47964793#ifdef INSTRUMENTATION
    4797 m_cpt_dcache_dir_write++;
    4798 #endif
    4799 
     4794                m_cpt_dcache_dir_write++;
     4795#endif
    48004796                size_t way = r_dcache_miss_way.read();
    48014797                size_t set = r_dcache_miss_set.read();
    48024798                if (r_dcache_read_state.read())
    48034799                {
    4804                     r_dcache.write_dir( r_dcache_save_paddr.read(),
    4805                                         r_dcache_miss_way.read(),
    4806                                         r_dcache_miss_set.read(),
    4807                                         CACHE_SLOT_STATE_VALID_CC );
    4808 
    4809                     r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
    4810 
     4800                    r_dcache.write_dir(r_dcache_save_paddr.read(),
     4801                                       r_dcache_miss_way.read(),
     4802                                       r_dcache_miss_set.read(),
     4803                                       CACHE_SLOT_STATE_VALID_CC);
     4804
     4805                    r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_NOT_DIRTY;
    48114806                }
    48124807                else
    48134808                {
    4814                     r_dcache.write_dir( r_dcache_save_paddr.read(),
    4815                                         r_dcache_miss_way.read(),
    4816                                         r_dcache_miss_set.read(),
    4817                                         CACHE_SLOT_STATE_VALID_NCC );
    4818                     r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
    4819                     for (size_t word =0; word < m_dcache_words ; word++)
     4809                    r_dcache.write_dir(r_dcache_save_paddr.read(),
     4810                                       r_dcache_miss_way.read(),
     4811                                       r_dcache_miss_set.read(),
     4812                                       CACHE_SLOT_STATE_VALID_NCC);
     4813                    r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_NOT_DIRTY;
     4814                    for (size_t word = 0; word < m_dcache_words; word++)
    48204815                    {
    4821                         r_dcache_dirty_word[(way*m_dcache_sets +set)*m_dcache_words+word] = 0;
     4816                        r_dcache_dirty_word[(way * m_dcache_sets + set) * m_dcache_words + word] = 0;
    48224817                    }
    48234818
    48244819                    // STAT : WRITE ON ZOMBI NCC LINE
    4825                     r_dcache_zombi_ncc[r_dcache_miss_way.read()*m_dcache_sets+r_dcache_miss_set.read()] = true;
     4820                    r_dcache_zombi_ncc[r_dcache_miss_way.read() * m_dcache_sets + r_dcache_miss_set.read()] = true;
    48264821                }
    48274822
    48284823#if DEBUG_DCACHE
    4829 if ( m_debug_activated )
    4830 std::cout << "  <PROC " << name()
    4831           << " DCACHE_MISS_DIR_UPDT> Switch slot to VALID state"
    4832           << " PADDR = " << std::hex << r_dcache_save_paddr.read()
    4833           << " / WAY = "   << std::dec << r_dcache_miss_way.read()
    4834           << " / SET = "   << r_dcache_miss_set.read() << std::endl;
     4824                if (m_debug_activated)
     4825                    std::cout << "  <PROC " << name()
     4826                        << " DCACHE_MISS_DIR_UPDT> Switch slot to VALID state"
     4827                        << " PADDR = " << std::hex << r_dcache_save_paddr.read()
     4828                        << " / WAY = "   << std::dec << r_dcache_miss_way.read()
     4829                        << " / SET = "   << r_dcache_miss_set.read() << std::endl;
    48354830#endif
    48364831            }
    … …  
    48424837    }
    48434838    /////////////////////
    4844     case DCACHE_UNC_WAIT:  // waiting a response to an uncacheable read
     4839    case DCACHE_UNC_WAIT:  // waiting a response to an uncacheable read/write
    48454840    {
    48464841        // coherence clack request (from DSPIN CLACK)
    4847         if ( r_dcache_clack_req.read() )
     4842        if (r_dcache_clack_req.read())
    48484843        {
    48494844            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    48534848
    48544849        // coherence request (from CC_RECEIVE FSM)
    4855         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     4850        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    48564851        {
    48574852            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    48604855        }
    48614856
    4862         if ( r_vci_rsp_data_error.read() ) // bus error
    4863         {
    4864             if(r_dcache_vci_unc_write.read())
    4865                 r_mmu_detr           = MMU_WRITE_DATA_ILLEGAL_ACCESS;
     4857        if (r_vci_rsp_data_error.read()) // bus error
     4858        {
     4859            if (r_dcache_vci_unc_write.read())
     4860                r_mmu_detr = MMU_WRITE_DATA_ILLEGAL_ACCESS;
    48664861            else
    4867                 r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
     4862                r_mmu_detr = MMU_READ_DATA_ILLEGAL_ACCESS;
     4863
    48684864            r_mmu_dbvar          = m_dreq.addr;
    48694865            r_vci_rsp_data_error = false;
    … …  
    48734869            break;
    48744870        }
    4875         else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
     4871        else if (r_vci_rsp_fifo_dcache.rok())     // data available
    48764872        {
    48774873            // consume data
    … …  
    48804876
    48814877            // acknowledge the processor request if it has not been modified
    4882             if ( m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()) )
    4883             {
    4884                 m_drsp.valid        = true;
    4885                 m_drsp.error        = false;
    4886                 m_drsp.rdata        = r_vci_rsp_fifo_dcache.read();
     4878            if (m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()))
     4879            {
     4880                m_drsp.valid = true;
     4881                m_drsp.error = false;
     4882                m_drsp.rdata = r_vci_rsp_fifo_dcache.read();
    48874883            }
    48884884        }
    … …  
    48934889    {
    48944890        // coherence clack request (from DSPIN CLACK)
    4895         if ( r_dcache_clack_req.read() )
     4891        if (r_dcache_clack_req.read())
    48964892        {
    48974893            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    49014897
    49024898        // coherence request (from CC_RECEIVE FSM)
    4903         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     4899        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    49044900        {
    49054901            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    49084904        }
    49094905
    4910         if ( r_vci_rsp_data_error.read() ) // bus error
     4906        if (r_vci_rsp_data_error.read()) // bus error
    49114907        {
    49124908            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
    … …  
    49184914            break;
    49194915        }
    4920         else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
     4916        else if (r_vci_rsp_fifo_dcache.rok())     // data available
    49214917        {
    49224918            // consume data
    49234919            vci_rsp_fifo_dcache_get = true;
    49244920
    4925             if(r_dcache_ll_rsp_count.read() == 0) // first flit
     4921            if (r_dcache_ll_rsp_count.read() == 0) // first flit
    49264922            {
    49274923                // set key value in llsc reservation buffer
    49284924                r_dcache_llsc_key     = r_vci_rsp_fifo_dcache.read();
    4929                 r_dcache_ll_rsp_count = r_dcache_ll_rsp_count.read() + 1 ;
     4925                r_dcache_ll_rsp_count = r_dcache_ll_rsp_count.read() + 1;
    49304926            }
    49314927            else                                  // last flit
    49324928            {
    49334929                // acknowledge the processor request if it has not been modified
    4934                 if ( m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()) )
    4935                 {
    4936                     m_drsp.valid        = true;
    4937                     m_drsp.error        = false;
    4938                     m_drsp.rdata        = r_vci_rsp_fifo_dcache.read();
     4930                if (m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()))
     4931                {
     4932                    m_drsp.valid = true;
     4933                    m_drsp.error = false;
     4934                    m_drsp.rdata = r_vci_rsp_fifo_dcache.read();
    49394935                }
    49404936                r_dcache_fsm = DCACHE_IDLE;
    … …  
    49444940    }
    49454941    ////////////////////
    4946     case DCACHE_SC_WAIT:   // waiting VCI response to a SC transaction
     4942    case DCACHE_SC_WAIT: // waiting VCI response to a SC transaction
    49474943    {
    49484944        // coherence clack request (from DSPIN CLACK)
    4949         if ( r_dcache_clack_req.read() )
     4945        if (r_dcache_clack_req.read())
    49504946        {
    49514947            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    49554951
    49564952        // coherence request (from CC_RECEIVE FSM)
    4957         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     4953        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    49584954        {
    49594955            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    49624958        }
    49634959
    4964         if ( r_vci_rsp_data_error.read() )    // bus error
     4960        if (r_vci_rsp_data_error.read()) // bus error
    49654961        {
    49664962            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
    … …  
    49724968            break;
    49734969        }
    4974         else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
     4970        else if (r_vci_rsp_fifo_dcache.rok()) // response available
    49754971        {
    49764972            // consume response
    … …  
    49834979    }
    49844980    //////////////////////////
    4985     case DCACHE_DIRTY_GET_PTE:      // This sub_fsm set the PTE Dirty bit in memory
    4986                                     // before handling a processor WRITE or SC request
    4987                                     // Input argument is r_dcache_dirty_paddr
    4988                                     // In this first state, we get PTE value in dcache
    4989                                     // and post a CAS request to CMD FSM
     4981    case DCACHE_DIRTY_GET_PTE:  // This sub_fsm set the PTE Dirty bit in memory
     4982                                // before handling a processor WRITE or SC request
     4983                                // Input argument is r_dcache_dirty_paddr
     4984                                // In this first state, we get PTE value in dcache
     4985                                // and post a CAS request to CMD FSM
    49904986    {
    49914987        // get PTE in dcache
    … …  
    49974993
    49984994#ifdef INSTRUMENTATION
    4999 m_cpt_dcache_data_read++;
    5000 m_cpt_dcache_dir_read++;
    5001 #endif
    5002         r_dcache.read( r_dcache_dirty_paddr.read(),
    5003                        &pte,
    5004                        &way,
    5005                        &set,
    5006                        &word,
    5007                        &state );
    5008 
    5009         assert( (state == CACHE_SLOT_STATE_VALID_CC or state == CACHE_SLOT_STATE_VALID_NCC) and
     4995        m_cpt_dcache_data_read++;
     4996        m_cpt_dcache_dir_read++;
     4997#endif
     4998        r_dcache.read(r_dcache_dirty_paddr.read(),
     4999                      &pte,
     5000                      &way,
     5001                      &set,
     5002                      &word,
     5003                      &state);
     5004
     5005        assert((state == CACHE_SLOT_STATE_VALID_CC or state == CACHE_SLOT_STATE_VALID_NCC) and
    50105006        "error in DCACHE_DIRTY_TLB_SET: the PTE should be in dcache" );
    50115007
    50125008        // request CAS transaction to CMD_FSM
    5013         r_dcache_dirty_way  = way;
    5014         r_dcache_dirty_set  = set;
     5009        r_dcache_dirty_way = way;
     5010        r_dcache_dirty_set = set;
    50155011
    50165012        // check llsc reservation buffer
    5017         if (r_dcache_llsc_paddr.read() == r_dcache_dirty_paddr.read() )
     5013        if (r_dcache_llsc_paddr.read() == r_dcache_dirty_paddr.read())
    50185014            r_dcache_llsc_valid = false;
    50195015
    … …  
    50295025        else
    50305026        {
    5031             r_cas_islocal = true;
    5032             r_cas_local_way = way;
    5033             r_cas_local_set = set;
    5034             r_cas_local_word = word;
     5027            r_cas_local_way      = way;
     5028            r_cas_local_set      = set;
     5029            r_cas_local_word     = word;
    50355030            r_dcache_vci_cas_new = pte | PTE_D_MASK;
    5036         }
    5037 
    5038 
    5039             r_dcache_fsm        = DCACHE_DIRTY_WAIT;
     5031            r_cas_islocal        = true;
     5032        }
     5033
     5034        r_dcache_fsm = DCACHE_DIRTY_WAIT;
    50405035
    50415036#if DEBUG_DCACHE
    5042 if ( m_debug_activated )
    5043 {
    5044     std::cout << "  <PROC " << name()
    5045               << " DCACHE_DIRTY_GET_PTE> CAS request" << std::hex
    5046               << " / PTE_PADDR = " << r_dcache_dirty_paddr.read()
    5047               << " / PTE_VALUE = " << pte << std::dec
    5048               << " / SET = " << set
    5049               << " / WAY = " << way << std::endl;
    5050 }
     5037        if (m_debug_activated)
     5038        {
     5039            std::cout << "  <PROC " << name()
     5040                << " DCACHE_DIRTY_GET_PTE> CAS request" << std::hex
     5041                << " / PTE_PADDR = " << r_dcache_dirty_paddr.read()
     5042                << " / PTE_VALUE = " << pte << std::dec
     5043                << " / SET = " << set
     5044                << " / WAY = " << way << std::endl;
     5045        }
    50515046#endif
    50525047        break;
    50535048    }
    50545049    ///////////////////////
    5055     case DCACHE_DIRTY_WAIT:         // wait completion of CAS for PTE Dirty bit,
    5056                                     // and return to IDLE state when response is received.
    5057                                     // we don't care if the CAS is a failure:
    5058                                     // - if the CAS is a success, the coherence mechanism
    5059                                     //   updates the local copy.
    5060                                     // - if the CAS is a failure, we just retry the write.
     5050    case DCACHE_DIRTY_WAIT:    // wait completion of CAS for PTE Dirty bit,
     5051                               // and return to IDLE state when response is received.
     5052                               // we don't care if the CAS is a failure:
     5053                               // - if the CAS is a success, the coherence mechanism
     5054                               //   updates the local copy.
     5055                               // - if the CAS is a failure, we just retry the write.
    50615056    {
    50625057        uint32_t way  = r_cas_local_way.read();
    … …  
    50665061
    50675062        // coherence clack request (from DSPIN CLACK)
    5068         if ( r_dcache_clack_req.read() )
     5063        if (r_dcache_clack_req.read())
    50695064        {
    50705065            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    50745069
    50755070        // coherence request (from CC_RECEIVE FSM)
    5076         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     5071        if (r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    50775072        {
    50785073            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    50815076        }
    50825077
    5083         if (!r_cas_islocal.read())
    5084         {
    5085             if ( r_vci_rsp_data_error.read() )  // bus error
     5078        if (not r_cas_islocal.read())
     5079        {
     5080            if (r_vci_rsp_data_error.read())  // bus error
    50865081            {
    50875082                std::cout << "BUS ERROR in DCACHE_DIRTY_WAIT state" << std::endl;
    … …  
    50895084                exit(0);
    50905085            }
    5091             else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
     5086            else if (r_vci_rsp_fifo_dcache.rok()) // response available
    50925087            {
    50935088                vci_rsp_fifo_dcache_get = true;
    5094                 r_dcache_fsm            = DCACHE_IDLE;
     5089                r_dcache_fsm = DCACHE_IDLE;
    50955090#if DEBUG_DCACHE
    5096 if ( m_debug_activated )
    5097 {
    5098     std::cout << "  <PROC " << name()
    5099               << " DCACHE_DIRTY_WAIT> CAS completed" << std::endl;
    5100 }
     5091                if (m_debug_activated)
     5092                {
     5093                    std::cout << "  <PROC " << name()
     5094                        << " DCACHE_DIRTY_WAIT> CAS completed" << std::endl;
     5095                }
    51015096#endif
    51025097            }
    … …  
    51095104                           r_dcache_vci_cas_new.read());
    51105105
    5111             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    5112             {
    5113                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     5106            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
     5107            {
     5108                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
    51145109                r_dcache_tlb_inval_line  = nline;
    51155110                r_dcache_tlb_inval_set   = 0;
    … …  
    51195114            }
    51205115
    5121             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     5116            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
    51225117            {
    51235118                r_itlb.reset();
    51245119                r_dtlb.reset();
    5125                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
     5120                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_DIRTY;
    51265121
    51275122#if DEBUG_DCACHE
    5128                 if ( m_debug_activated )
     5123                if (m_debug_activated)
    51295124                {
    51305125                    std::cout << "  <PROC " << name()
    … …  
    51335128#endif
    51345129            }
    5135             r_dcache_fsm            = DCACHE_IDLE;
     5130            r_dcache_fsm = DCACHE_IDLE;
    51365131        }
    51375132        break;
    … …  
    51465141                            // The return state is defined in r_dcache_fsm_cc_save
    51475142    {
    5148         paddr_t  paddr = r_cc_receive_dcache_nline.read() * m_dcache_words * 4;
    5149         paddr_t  mask = ~((m_dcache_words<<2)-1);
    5150 
    5151 //#if DEBUG_DCACHE
    5152 //if ( m_debug_activated )
    5153 //{
    5154 //    std::cout << "  <PROC " << name() << std::hex
    5155 //              << " DCACHE_CC_CHECK> paddr = " << paddr
    5156 //              << " r_dcache_vci_paddr = " << r_dcache_vci_paddr.read()
    5157 //              << " mask = " << mask
    5158 //              << " (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT) = "
    5159 //              << (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT)
    5160 //              << " (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT) = "
    5161 //              << (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT)
    5162 //              << " ((r_dcache_vci_paddr.read() & mask) == (paddr & mask)) = "
    5163 //              << ((r_dcache_vci_paddr.read() & mask) == (paddr & mask))
    5164 //              << std::dec <<std::endl;
    5165 //}
    5166 //#endif
     5143        paddr_t paddr = r_cc_receive_dcache_nline.read() * m_dcache_words * 4;
     5144        paddr_t mask = ~((m_dcache_words << 2) - 1);
     5145
    51675146        // CLACK handler
    51685147        // We switch the directory slot to EMPTY state and reset
    51695148        // r_dcache_miss_clack if the cleanup ack is matching a pending miss.
    5170         if ( r_dcache_clack_req.read() )
    5171         {
    5172             if ( m_dreq.valid ) m_cost_data_miss_frz++;
     5149        if (r_dcache_clack_req.read())
     5150        {
     5151            if (m_dreq.valid) m_cost_data_miss_frz++;
    51735152
    51745153#ifdef INSTRUMENTATION
    5175 m_cpt_dcache_dir_write++;
    5176 #endif
    5177             r_dcache.write_dir( 0,
    5178                                 r_dcache_clack_way.read(),
    5179                                 r_dcache_clack_set.read(),
    5180                                 CACHE_SLOT_STATE_EMPTY);
     5154            m_cpt_dcache_dir_write++;
     5155#endif
     5156            r_dcache.write_dir(0,
     5157                               r_dcache_clack_way.read(),
     5158                               r_dcache_clack_set.read(),
     5159                               CACHE_SLOT_STATE_EMPTY);
    51815160
    51825161            // STAT : WRITE ON ZOMBI NCC LINE
    5183             r_dcache_zombi_ncc[r_dcache_clack_way.read()*m_dcache_sets+r_dcache_clack_set.read()] = false;
    5184 
    5185             if ( (r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
    5186                  (r_dcache_miss_way.read() == r_dcache_clack_way.read()) )
     5162            r_dcache_zombi_ncc[r_dcache_clack_way.read() * m_dcache_sets + r_dcache_clack_set.read()] = false;
     5163
     5164            if ((r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
     5165                (r_dcache_miss_way.read() == r_dcache_clack_way.read()))
    51875166            {
    51885167                  r_dcache_miss_clack = false;
    … …  
    51955174
    51965175#if DEBUG_DCACHE
    5197 if ( m_debug_activated )
    5198 {
    5199     std::cout << "  <PROC " << name()
    5200               << " DCACHE_CC_CHECK> CC_TYPE_CLACK Switch slot to EMPTY state"
    5201               << " set = " << r_dcache_clack_set.read()
    5202               << " / way = " << r_dcache_clack_way.read() << std::endl;
    5203 }
    5204 #endif
    5205             break;
    5206         }
    5207 
     5176            if (m_debug_activated)
     5177            {
     5178                std::cout << "  <PROC " << name()
     5179                    << " DCACHE_CC_CHECK> CLACK for PADDR " << std::hex << paddr
     5180                    << " Switch slot to EMPTY state : "
     5181                    << " set = " << std::dec << r_dcache_clack_set.read()
     5182                    << " / way = " << r_dcache_clack_way.read() << std::endl;
     5183            }
     5184#endif
     5185            break;
     5186        }
     5187
     5188        assert(not r_dcache_cc_send_req.read() and
     5189        "CC_SEND must be available in DCACHE_CC_CHECK");
    52085190
    52095191        // Match between MISS address and CC address
    … …  
    52115193        // because the CLACK access the directory but the MISS match dont.
    52125194        if (r_cc_receive_dcache_req.read() and
    5213           ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT  )  or
    5214            (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT    )  or
     5195          ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT)  or
     5196           (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT)  or
    52155197           (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT)) and
    52165198          ((r_dcache_vci_paddr.read() & mask) == (paddr & mask))) // matching
    … …  
    52235205            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
    52245206            {
    5225                 r_dcache_fsm        = DCACHE_CC_UPDT;
    5226                 r_dcache_cc_word    = r_cc_receive_word_idx.read();
     5207                r_dcache_fsm     = DCACHE_CC_UPDT;
     5208                r_dcache_cc_word = r_cc_receive_word_idx.read();
    52275209
    52285210                // just pop the fifo , don't write in icache
    … …  
    52375219
    52385220#if DEBUG_DCACHE
    5239 if ( m_debug_activated )
    5240 {
    5241     std::cout << "  <PROC " << name()
    5242               << " DCACHE_CC_CHECK> Coherence request matching a pending miss:"
    5243               << " PADDR = " << std::hex << paddr << std::endl;
    5244 }
    5245 #endif
    5246         }
    5247 
    5248 
    5249         assert ( not r_dcache_cc_send_req.read() and "CC_SEND must be available in DCACHE_CC_CHECK" );
     5221            if (m_debug_activated)
     5222            {
     5223                std::cout << "  <PROC " << name()
     5224                    << " DCACHE_CC_CHECK> Coherence request matching a pending miss:"
     5225                    << " PADDR = " << std::hex << paddr << std::endl;
     5226            }
     5227#endif
     5228        }
    52505229
    52515230        // CC request handler
    … …  
    52575236
    52585237#ifdef INSTRUMENTATION
    5259 m_cpt_dcache_dir_read++;
    5260 #endif
    5261         r_dcache.read_dir( paddr,
    5262                            &state,
    5263                            &way,
    5264                            &set,
    5265                            &word ); // unused
     5238        m_cpt_dcache_dir_read++;
     5239#endif
     5240        r_dcache.read_dir(paddr,
     5241                          &state,
     5242                          &way,
     5243                          &set,
     5244                          &word); // unused
    52665245
    52675246        r_dcache_cc_state = state;
    … …  
    52695248        r_dcache_cc_set = set;
    52705249
    5271         if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))  // hit
     5250        if ((state == CACHE_SLOT_STATE_VALID_CC) or
     5251            (state == CACHE_SLOT_STATE_VALID_NCC))  // hit
    52725252        {
    52735253            // need to update the cache state
    … …  
    52765256            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)  // hit update
    52775257            {
    5278                 r_dcache_fsm          = DCACHE_CC_UPDT;
    5279                 r_dcache_cc_word      = r_cc_receive_word_idx.read();
     5258                r_dcache_fsm     = DCACHE_CC_UPDT;
     5259                r_dcache_cc_word = r_cc_receive_word_idx.read();
    52805260            }
    52815261            else if (r_cc_receive_dcache_type.read() == CC_TYPE_INVAL)   // hit inval
    … …  
    52835263                if (state == CACHE_SLOT_STATE_VALID_NCC)
    52845264                {
    5285                     r_dcache_cc_inval_addr = (paddr &~0x3F);
     5265                    r_dcache_cc_inval_addr = (paddr & ~0x3F);
    52865266                    r_dcache_cc_inval_data_cpt = 0;
    52875267                }
    5288                 r_dcache_fsm          = DCACHE_CC_INVAL;
    5289                 r_dcache_dirty_save   = false;
     5268                r_dcache_fsm        = DCACHE_CC_INVAL;
     5269                r_dcache_dirty_save = false;
    52905270            }
    52915271        }
    … …  
    52935273        {
    52945274            // multicast acknowledgement required in case of update
    5295             if(r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
    5296             {
    5297                 r_dcache_fsm           = DCACHE_CC_UPDT;
    5298                 r_dcache_cc_word       = r_cc_receive_word_idx.read();
     5275            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
     5276            {
     5277                r_dcache_fsm     = DCACHE_CC_UPDT;
     5278                r_dcache_cc_word = r_cc_receive_word_idx.read();
    52995279
    53005280                // just pop the fifo , don't write in icache
    … …  
    53095289
    53105290#if DEBUG_DCACHE
    5311 if ( m_debug_activated )
    5312 {
    5313     std::cout << "  <PROC " << name()
    5314               << " DCACHE_CC_CHECK> Coherence request received:"
    5315               << " PADDR = " << std::hex << paddr
    5316               << " / TYPE = " << std::dec << r_cc_receive_dcache_type.read()
    5317               << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) << std::endl;
    5318 }
     5291        if (m_debug_activated)
     5292        {
     5293            std::cout << "  <PROC " << name()
     5294                << " DCACHE_CC_CHECK> Coherence request received:"
     5295                << " PADDR = " << std::hex << paddr
     5296                << " / TYPE = " << std::dec << r_cc_receive_dcache_type.read()
     5297                << " / HIT = " << ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) << std::endl;
     5298        }
    53195299#endif
    53205300
    53215301        break;
    53225302    }
    5323 
    53245303    /////////////////////
    53255304    case DCACHE_CC_INVAL: // hit inval: switch slot to ZOMBI state and send a
    … …  
    53275306                          // TLBs
    53285307    {
    5329         size_t way    = r_dcache_cc_way.read();
    5330         size_t set    = r_dcache_cc_set.read();
    5331         int      cache_state = r_dcache_cc_state.read();
    5332         bool     dirty_save = false;
     5308        size_t way = r_dcache_cc_way.read();
     5309        size_t set = r_dcache_cc_set.read();
     5310        int  cache_state = r_dcache_cc_state.read();
     5311        bool dirty_save = false;
    53335312
    53345313        if (r_dcache_cc_need_write.read())
    53355314        {
    5336             if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    5337             {
    5338                 r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;//need to remember it was dirty for cleanup
     5315            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
     5316            {
     5317                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_NOT_DIRTY; //need to remember it was dirty for cleanup
    53395318                dirty_save = true;
    53405319                r_dcache_dirty_save = true;
    5341                 r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
    5342                 r_dcache_tlb_inval_set   = 0;
    5343                 r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    5344                 r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     5320                r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
     5321                r_dcache_tlb_inval_set  = 0;
     5322                r_dcache_fsm_scan_save  = r_dcache_fsm.read();
     5323                r_dcache_fsm = DCACHE_INVAL_TLB_SCAN;
    53455324                break;
    53465325            }
    53475326            else
    53485327            {
    5349                 if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
     5328                if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
    53505329                {
    53515330                    r_itlb.reset();
    53525331                    r_dtlb.reset();
    5353                     r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     5332                    r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_NOT_DIRTY;
    53545333                    dirty_save = true;
    53555334                    r_dcache_dirty_save = true;
    53565335#if DEBUG_DCACHE
    5357 if ( m_debug_activated )
    5358 {
    5359     std::cout << "  <PROC " << name()
    5360               << " DCACHE_CC_INVAL> Flush DTLB & ITLB" << std::endl;
    5361 }
     5336                    if (m_debug_activated)
     5337                    {
     5338                        std::cout << "  <PROC " << name()
     5339                            << " DCACHE_CC_INVAL> Flush DTLB & ITLB" << std::endl;
     5340                    }
    53625341#endif
    53635342                }
    … …  
    53655344                // If the type of inval request from Memcache is configuration
    53665345                // (software), we send a classic CLEANUP
    5367                 if (cache_state == CACHE_SLOT_STATE_VALID_CC or r_cc_receive_dcache_inval_is_config.read())
    5368                 {
    5369                     r_dcache.write_dir( way,
    5370                                         set,
    5371                                         CACHE_SLOT_STATE_ZOMBI );
    5372                 }
    5373 
     5346                if (cache_state == CACHE_SLOT_STATE_VALID_CC or
     5347                    r_cc_receive_dcache_inval_is_config.read())
     5348                {
     5349                    r_dcache.write_dir(way,
     5350                                       set,
     5351                                       CACHE_SLOT_STATE_ZOMBI);
     5352                }
    53745353                r_dcache_cc_need_write = false;
    53755354            }
    53765355        }
    5377         assert (not r_dcache_cc_send_req.read() &&
    5378                     "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    5379                     "must not be set");
     5356        assert(not r_dcache_cc_send_req.read() and
     5357               "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
     5358               "must not be set");
    53805359        // coherence request completed
    53815360        r_cc_receive_dcache_req = false;
    … …  
    53865365        r_dcache_cc_send_type = CC_TYPE_CLEANUP;
    53875366
    5388         if (cache_state == CACHE_SLOT_STATE_VALID_NCC and not r_cc_receive_dcache_inval_is_config.read())
     5367        if (cache_state == CACHE_SLOT_STATE_VALID_NCC and
     5368            not r_cc_receive_dcache_inval_is_config.read())
    53895369        {
    53905370            r_dcache_cc_cleanup_line_ncc = true;
    5391             if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY) or r_dcache_dirty_save.read() or dirty_save) //must send data
     5371            if ((r_dcache_content_state[way * m_dcache_sets + set] != LINE_CACHE_DATA_NOT_DIRTY) or
     5372                 r_dcache_dirty_save.read() or
     5373                 dirty_save) //must send data
    53925374            {
    53935375                r_dcache_cc_cleanup_updt_data = true;
    5394                 for (size_t w = 0; w< m_dcache_words; w++)
    5395                 {
    5396                     m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
    5397                 }
    5398 
    5399                 r_dcache_fsm          = DCACHE_CC_INVAL_DATA;
     5376                for (size_t w = 0; w < m_dcache_words; w++)
     5377                {
     5378                    m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets * way + set) * m_dcache_words + w];
     5379                }
     5380
     5381                r_dcache_fsm = DCACHE_CC_INVAL_DATA;
    54005382            }
    54015383            else
    54025384            {
    5403                 r_dcache.write_dir( way,
    5404                                     set,
    5405                                     CACHE_SLOT_STATE_ZOMBI );
     5385                r_dcache.write_dir(way,
     5386                                   set,
     5387                                   CACHE_SLOT_STATE_ZOMBI);
    54065388
    54075389                r_dcache_cc_cleanup_updt_data = false;
    … …  
    54175399        break;
    54185400    }
    5419 
    54205401    /////////////////////
    54215402    case DCACHE_CC_INVAL_DATA:
    … …  
    54235404
    54245405        uint32_t rdata;
    5425         size_t   way = 0; // to avoid gcc warning
    5426         size_t   set = 0; // to avoid gcc warning
    5427         size_t   word;
     5406        size_t way = 0; // to avoid gcc warning
     5407        size_t set = 0; // to avoid gcc warning
     5408        size_t word;
    54285409        r_dcache.read_neutral(r_dcache_cc_inval_addr.read(),
    54295410                              &rdata,
    … …  
    54315412                              &set,
    54325413                              &word);
    5433         if(r_cc_send_data_fifo.wok())
     5414        if (r_cc_send_data_fifo.wok())
    54345415        {
    54355416            r_dcache_cc_inval_addr = r_dcache_cc_inval_addr.read() + 4;
    54365417
    5437             cleanup_data_updt_fifo_dcache_put   = true;
    5438             cleanup_data_updt_fifo_dcache_data  = rdata;
     5418            cleanup_data_updt_fifo_dcache_put = true;
     5419            cleanup_data_updt_fifo_dcache_data = rdata;
    54395420
    54405421            r_dcache_cc_inval_data_cpt = r_dcache_cc_inval_data_cpt.read() + 1;
    5441             if(r_dcache_cc_inval_data_cpt.read() == (m_dcache_words - 1))
     5422            if (r_dcache_cc_inval_data_cpt.read() == (m_dcache_words - 1))
    54425423            {
    54435424                r_dcache_cc_inval_data_cpt = 0;
    5444                 r_dcache_fsm          = r_dcache_fsm_cc_save.read();
     5425                r_dcache_fsm = r_dcache_fsm_cc_save.read();
    54455426                r_dcache.write_dir(way,
    54465427                                   set,
    5447                                    CACHE_SLOT_STATE_ZOMBI );
     5428                                   CACHE_SLOT_STATE_ZOMBI);
    54485429            }
    54495430        }
    … …  
    54515432    }
    54525433    ///////////////////
    5453     case DCACHE_CC_UPDT:        // hit update: write one word per cycle,
    5454                                 // after possible invalidation of copies in TLBs
    5455     {
    5456         size_t word       = r_dcache_cc_word.read();
    5457         size_t way        = r_dcache_cc_way.read();
    5458         size_t set        = r_dcache_cc_set.read();
    5459 
    5460             if (r_dcache_cc_need_write.read())
    5461             {
    5462                 if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    5463                 {
    5464                     r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
    5465                     r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
    5466                     r_dcache_tlb_inval_set   = 0;
    5467                     r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    5468                     r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    5469                     break;
    5470                 }
    5471                 if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
    5472                 {
    5473                     r_itlb.reset();
    5474                     r_dtlb.reset();
    5475                     r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     5434    case DCACHE_CC_UPDT: // hit update: write one word per cycle,
     5435                         // after possible invalidation of copies in TLBs
     5436    {
     5437        size_t word = r_dcache_cc_word.read();
     5438        size_t way  = r_dcache_cc_way.read();
     5439        size_t set  = r_dcache_cc_set.read();
     5440
     5441        if (r_dcache_cc_need_write.read())
     5442        {
     5443            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_IN_TLB)
     5444            {
     5445                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_NOT_DIRTY;
     5446                r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
     5447                r_dcache_tlb_inval_set  = 0;
     5448                r_dcache_fsm_scan_save  = r_dcache_fsm.read();
     5449                r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
     5450                break;
     5451            }
     5452            if (r_dcache_content_state[way * m_dcache_sets + set] == LINE_CACHE_CONTAINS_PTD)
     5453            {
     5454                r_itlb.reset();
     5455                r_dtlb.reset();
     5456                r_dcache_content_state[way * m_dcache_sets + set] = LINE_CACHE_DATA_NOT_DIRTY;
    54765457
    54775458#if DEBUG_DCACHE
    5478 if ( m_debug_activated )
    5479 {
    5480     std::cout << "  <PROC " << name()
    5481               << " DCACHE_CC_UPDT> Flush DTLB & ITLB" << std::endl;
    5482 }
    5483 #endif
    5484                 }
    5485 
    5486                 assert (not r_dcache_cc_send_req.read() &&
    5487                         "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    5488                         "must not be set");
    5489 
    5490                 if ( not r_cc_receive_updt_fifo_be.rok() ) break;
     5459                if (m_debug_activated)
     5460                {
     5461                    std::cout << "  <PROC " << name()
     5462                        << " DCACHE_CC_UPDT> Flush DTLB & ITLB" << std::endl;
     5463                }
     5464#endif
     5465            }
     5466
     5467            assert(not r_dcache_cc_send_req.read() &&
     5468                   "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
     5469                   "must not be set");
     5470
     5471            if (not r_cc_receive_updt_fifo_be.rok()) break;
    54915472
    54925473#ifdef INSTRUMENTATION
    5493 m_cpt_dcache_data_write++;
    5494 #endif
    5495             r_dcache.write( way,
    5496                             set,
    5497                             word,
    5498                             r_cc_receive_updt_fifo_data.read(),
    5499                             r_cc_receive_updt_fifo_be.read() );
     5474            m_cpt_dcache_data_write++;
     5475#endif
     5476            r_dcache.write(way,
     5477                           set,
     5478                           word,
     5479                           r_cc_receive_updt_fifo_data.read(),
     5480                           r_cc_receive_updt_fifo_be.read());
    55005481
    55015482            r_dcache_cc_word = word + 1;
    55025483
    55035484#if DEBUG_DCACHE
    5504 if ( m_debug_activated )
    5505 {
    5506     std::cout << "  <PROC " << name()
    5507               << " DCACHE_CC_UPDT> Write one word" << std::dec
    5508               << " / WAY = " << way
    5509               << " / SET = " << set
    5510               << " / WORD = " << word
    5511               << " / VALUE = " << std::hex << r_cc_receive_updt_fifo_data.read() << std::endl;
    5512 }
    5513 #endif
    5514         }
    5515 
    5516         if ( not r_cc_receive_updt_fifo_be.rok() ) break;
    5517 
    5518         if ( r_cc_receive_updt_fifo_eop.read() )  // last word
     5485            if (m_debug_activated)
     5486            {
     5487                std::cout << "  <PROC " << name()
     5488                    << " DCACHE_CC_UPDT> Write one word" << std::dec
     5489                    << " / WAY = " << way
     5490                    << " / SET = " << set
     5491                    << " / WORD = " << word
     5492                    << " / VALUE = " << std::hex << r_cc_receive_updt_fifo_data.read() << std::endl;
     5493            }
     5494#endif
     5495        }
     5496
     5497        if (not r_cc_receive_updt_fifo_be.rok()) break;
     5498
     5499        if (r_cc_receive_updt_fifo_eop.read())  // last word
    55195500        {
    55205501            // no need to write in the cache anymore
    … …  
    55285509            r_dcache_cc_send_updt_tab_idx = r_cc_receive_dcache_updt_tab_idx.read();
    55295510            r_dcache_cc_send_type         = CC_TYPE_MULTI_ACK;
    5530 
    55315511            r_dcache_fsm                  = r_dcache_fsm_cc_save.read();
    55325512        }
    … …  
    55385518    }
    55395519    ///////////////////////////
    5540     case DCACHE_INVAL_TLB_SCAN:         // Scan sequencially all sets for both ITLB & DTLB
    5541                                         // It makes assumption: m_itlb_sets == m_dtlb_sets
    5542                                         // All ways are handled in parallel.
    5543                                         // We enter this state when a DCACHE line is modified,
    5544                                         // and there is a copy in itlb or dtlb.
    5545                                         // It can be caused by:
    5546                                         // - a coherence inval or updt transaction,
    5547                                         // - a line inval caused by a cache miss
    5548                                         // - a processor XTN inval request,
    5549                                         // - a WRITE hit,
    5550                                         // - a Dirty bit update
    5551                                         // Input arguments are:
    5552                                         // - r_dcache_tlb_inval_line
    5553                                         // - r_dcache_tlb_inval_set
    5554                                         // - r_dcache_fsm_scan_save
     5520    case DCACHE_INVAL_TLB_SCAN:  // Scan sequencially all sets for both ITLB & DTLB
     5521                                 // It makes assumption: m_itlb_sets == m_dtlb_sets
     5522                                 // All ways are handled in parallel.
     5523                                 // We enter this state when a DCACHE line is modified,
     5524                                 // and there is a copy in itlb or dtlb.
     5525                                 // It can be caused by:
     5526                                 // - a coherence inval or updt transaction,
     5527                                 // - a line inval caused by a cache miss
     5528                                 // - a processor XTN inval request,
     5529                                 // - a WRITE hit,
     5530                                 // - a Dirty bit update
     5531                                 // Input arguments are:
     5532                                 // - r_dcache_tlb_inval_line
     5533                                 // - r_dcache_tlb_inval_set
     5534                                 // - r_dcache_fsm_scan_save
    55555535    {
    55565536        paddr_t line = r_dcache_tlb_inval_line.read();
    5557         size_t  set = r_dcache_tlb_inval_set.read();
    5558         size_t  way;
    5559         bool    ok;
    5560 
    5561         for ( way = 0 ; way < m_itlb_ways ; way++ )
    5562         {
    5563             ok = r_itlb.inval( line, way, set );
     5537        size_t set = r_dcache_tlb_inval_set.read();
     5538        size_t way;
     5539        bool ok;
     5540
     5541        for (way = 0; way < m_itlb_ways; way++)
     5542        {
     5543            ok = r_itlb.inval(line, way, set);
    55645544
    55655545#if DEBUG_DCACHE
    5566 if ( m_debug_activated and ok )
    5567 {
    5568     std::cout << "  <PROC " << name()
    5569               << ".DCACHE_INVAL_TLB_SCAN> Invalidate ITLB entry:" << std::hex
    5570               << " line = " << line << std::dec
    5571               << " / set = " << set
    5572               << " / way = " << way << std::endl;
    5573 }
    5574 #endif
    5575         }
    5576 
    5577         for ( way = 0 ; way < m_dtlb_ways ; way++ )
    5578         {
    5579             ok = r_dtlb.inval( line, way, set );
     5546            if (m_debug_activated and ok)
     5547            {
     5548                std::cout << "  <PROC " << name()
     5549                    << ".DCACHE_INVAL_TLB_SCAN> Invalidate ITLB entry:" << std::hex
     5550                    << " line = " << line << std::dec
     5551                    << " / set = " << set
     5552                    << " / way = " << way << std::endl;
     5553            }
     5554#endif
     5555        }
     5556
     5557        for (way = 0; way < m_dtlb_ways; way++)
     5558        {
     5559            ok = r_dtlb.inval(line, way, set);
    55805560
    55815561#if DEBUG_DCACHE
    5582 if ( m_debug_activated and ok )
    5583 std::cout << "  <PROC " << name() << " DCACHE_INVAL_TLB_SCAN>"
    5584           << " Invalidate DTLB entry" << std::hex
    5585           << " / line = " << line << std::dec
    5586           << " / set = " << set
    5587           << " / way = " << way << std::endl;
     5562            if (m_debug_activated and ok)
     5563            {
     5564                std::cout << "  <PROC " << name() << " DCACHE_INVAL_TLB_SCAN>"
     5565                    << " Invalidate DTLB entry" << std::hex
     5566                    << " / line = " << line << std::dec
     5567                    << " / set = " << set
     5568                    << " / way = " << way << std::endl;
     5569            }
    55885570#endif
    55895571        }
    55905572
    55915573        // return to the calling state when TLB inval completed
    5592         if ( r_dcache_tlb_inval_set.read() == (m_dtlb_sets-1) )
     5574        if (r_dcache_tlb_inval_set.read() == (m_dtlb_sets - 1))
    55935575        {
    55945576            r_dcache_fsm = r_dcache_fsm_scan_save.read();
    … …  
    56095591    // The simulation exit if the number of consecutive frozen cycles
    56105592    // is larger than the m_max_frozen_cycles (constructor parameter)
    5611     if ( (m_ireq.valid and not m_irsp.valid) or (m_dreq.valid and not m_drsp.valid) )
    5612     {
    5613         m_cpt_frz_cycles++;         // used for instrumentation
    5614         m_cpt_stop_simulation++;    // used for debug
    5615         if ( m_cpt_stop_simulation > m_max_frozen_cycles )
     5593    if ((m_ireq.valid and not m_irsp.valid) or (m_dreq.valid and not m_drsp.valid))
     5594    {
     5595        m_cpt_frz_cycles++;      // used for instrumentation
     5596        m_cpt_stop_simulation++; // used for debug
     5597        if (m_cpt_stop_simulation > m_max_frozen_cycles)
    56165598        {
    56175599            std::cout << std::dec << "ERROR in CC_VCACHE_WRAPPER " << name() << std::endl
    … …  
    56305612    /////////// execute one iss cycle /////////////////////////////////
    56315613    {
    5632     uint32_t it = 0;
    5633     for (size_t i=0; i<(size_t)iss_t::n_irq; i++) if(p_irq[i].read()) it |= (1<<i);
    5634     r_iss.executeNCycles(1, m_irsp, m_drsp, it);
     5614        uint32_t it = 0;
     5615        for (size_t i = 0; i < (size_t) iss_t::n_irq; i++) if (p_irq[i].read()) it |= (1 << i);
     5616        r_iss.executeNCycles(1, m_irsp, m_drsp, it);
    56355617    }
    56365618
    … …  
    56765658
    56775659
    5678     switch ( r_vci_cmd_fsm.read() )
     5660    switch (r_vci_cmd_fsm.read())
    56795661    {
    56805662        //////////////
    … …  
    56885670            // using the r_vci_cmd_imiss_prio flip-flop.
    56895671
    5690             size_t      wbuf_min;
    5691             size_t      wbuf_max;
     5672            size_t wbuf_min;
     5673            size_t wbuf_max;
    56925674
    56935675            bool dcache_miss_req = r_dcache_vci_miss_req.read() and
    5694                  ( not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read() );
    5695 
    5696             bool dcache_ll_req   = r_dcache_vci_ll_req.read() and
    5697                  ( not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read() );
    5698 
    5699             bool dcache_sc_req   = r_dcache_vci_sc_req.read() and
    5700                  ( not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read() );
    5701 
    5702             bool dcache_cas_req   = r_dcache_vci_cas_req.read() and
    5703                  ( not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read() );
     5676                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
     5677
     5678            bool dcache_ll_req = r_dcache_vci_ll_req.read() and
     5679                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
     5680
     5681            bool dcache_sc_req = r_dcache_vci_sc_req.read() and
     5682                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
     5683
     5684            bool dcache_cas_req = r_dcache_vci_cas_req.read() and
     5685                 (not r_icache_miss_req.read() or not r_vci_cmd_imiss_prio.read());
    57045686
    57055687            bool icache_miss_req = r_icache_miss_req.read() and
    5706                  ( not (r_dcache_vci_miss_req.read() or
    5707                         r_dcache_vci_ll_req.read()   or
    5708                         r_dcache_vci_cas_req.read()  or
    5709                         r_dcache_vci_sc_req.read())
    5710                      or r_vci_cmd_imiss_prio.read() );
     5688                 (not (r_dcache_vci_miss_req.read() or
     5689                       r_dcache_vci_ll_req.read()   or
     5690                       r_dcache_vci_cas_req.read()  or
     5691                       r_dcache_vci_sc_req.read())  or
     5692                       r_vci_cmd_imiss_prio.read());
    57115693
    57125694            // 1 - Data unc write
    5713             if ( r_dcache_vci_unc_req.read() and r_dcache_vci_unc_write.read())
     5695            if (r_dcache_vci_unc_req.read() and r_dcache_vci_unc_write.read())
    57145696            {
    57155697                r_vci_cmd_fsm        = CMD_DATA_UNC_WRITE;
    57165698                r_dcache_vci_unc_req = false;
    5717 //                m_cpt_dunc_transaction++;
    57185699            }
    57195700            // 2 data read miss
    5720             else if ( dcache_miss_req and r_wbuf.miss(r_dcache_vci_paddr.read()) )
     5701            else if (dcache_miss_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
    57215702            {
    57225703                r_vci_cmd_fsm         = CMD_DATA_MISS;
    57235704                r_dcache_vci_miss_req = false;
    57245705                r_vci_cmd_imiss_prio  = true;
    5725                 m_cpt_dmiss_transaction++;
    57265706            }
    57275707            // 3 - Data Read Uncachable
    5728             else if ( r_dcache_vci_unc_req.read() and not r_dcache_vci_unc_write.read() )
     5708            else if (r_dcache_vci_unc_req.read() and not r_dcache_vci_unc_write.read())
    57295709            {
    57305710                r_vci_cmd_fsm        = CMD_DATA_UNC_READ;
    57315711                r_dcache_vci_unc_req = false;
    5732                 m_cpt_dunc_transaction++;
    57335712            }
    57345713            // 4 - Data Linked Load
    5735             else if ( dcache_ll_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
     5714            else if (dcache_ll_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
    57365715            {
    57375716                r_vci_cmd_fsm         = CMD_DATA_LL;
    57385717                r_dcache_vci_ll_req   = false;
    57395718                r_vci_cmd_imiss_prio  = true;
    5740                 m_cpt_ll_transaction++;
    57415719            }
    57425720            // 5 - Instruction Miss
    5743             else if ( icache_miss_req and r_wbuf.miss(r_icache_vci_paddr.read()) )
     5721            else if (icache_miss_req and r_wbuf.miss(r_icache_vci_paddr.read()))
    57445722            {
    57455723                r_vci_cmd_fsm        = CMD_INS_MISS;
    57465724                r_icache_miss_req    = false;
    57475725                r_vci_cmd_imiss_prio = false;
    5748                 m_cpt_imiss_transaction++;
    57495726            }
    57505727            // 6 - Instruction Uncachable
    5751             else if ( r_icache_unc_req.read() )
    5752             {
    5753                 r_vci_cmd_fsm       = CMD_INS_UNC;
    5754                 r_icache_unc_req    = false;
    5755                 //m_cpt_iunc_transaction++;
     5728            else if (r_icache_unc_req.read())
     5729            {
     5730                r_vci_cmd_fsm    = CMD_INS_UNC;
     5731                r_icache_unc_req = false;
    57565732            }
    57575733            // 7 - Data Write
    5758             else if ( r_wbuf.rok(&wbuf_min, &wbuf_max) )
    5759             {
    5760                 r_vci_cmd_fsm       = CMD_DATA_WRITE;
    5761                 r_vci_cmd_cpt       = wbuf_min;
    5762                 r_vci_cmd_min       = wbuf_min;
    5763                 r_vci_cmd_max       = wbuf_max;
     5734            else if (r_wbuf.rok(&wbuf_min, &wbuf_max))
     5735            {
     5736                r_vci_cmd_fsm = CMD_DATA_WRITE;
     5737                r_vci_cmd_cpt = wbuf_min;
     5738                r_vci_cmd_min = wbuf_min;
     5739                r_vci_cmd_max = wbuf_max;
    57645740                m_cpt_write_transaction++;
    5765                 m_length_write_transaction += (wbuf_max-wbuf_min+1);
     5741                m_length_write_transaction += (wbuf_max - wbuf_min + 1);
    57665742            }
    57675743            // 8 - Data Store Conditionnal
    5768             else if ( dcache_sc_req and r_wbuf.miss(r_dcache_vci_paddr.read()) )
    5769             {
    5770                 r_vci_cmd_fsm           = CMD_DATA_SC;
    5771                 r_dcache_vci_sc_req     = false;
    5772                 r_vci_cmd_imiss_prio    = true;
    5773                 r_vci_cmd_cpt           = 0;
    5774                 //m_cpt_sc_transaction++;
     5744            else if (dcache_sc_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
     5745            {
     5746                r_vci_cmd_fsm        = CMD_DATA_SC;
     5747                r_dcache_vci_sc_req  = false;
     5748                r_vci_cmd_imiss_prio = true;
     5749                r_vci_cmd_cpt        = 0;
    57755750            }
    57765751            // 9 - Compare And Swap
    5777             else if ( dcache_cas_req and r_wbuf.miss(r_dcache_vci_paddr.read()) )
    5778             {
    5779                 r_vci_cmd_fsm           = CMD_DATA_CAS;
    5780                 r_dcache_vci_cas_req    = false;
    5781                 r_vci_cmd_imiss_prio    = true;
    5782                 r_vci_cmd_cpt           = 0;
    5783                 //m_cpt_cas_transaction++;
     5752            else if (dcache_cas_req and r_wbuf.miss(r_dcache_vci_paddr.read()))
     5753            {
     5754                r_vci_cmd_fsm        = CMD_DATA_CAS;
     5755                r_dcache_vci_cas_req = false;
     5756                r_vci_cmd_imiss_prio = true;
     5757                r_vci_cmd_cpt        = 0;
    57845758            }
    57855759
    57865760#if DEBUG_CMD
    5787 if ( m_debug_activated )
    5788 {
    5789 std::cout << "  <PROC " << name() << " CMD_IDLE>"
    5790           << " / dmiss_req = " << dcache_miss_req
    5791           << " / imiss_req = " << icache_miss_req
    5792           << std::endl;
    5793 }
     5761            if (m_debug_activated)
     5762            {
     5763                std::cout << "  <PROC " << name() << " CMD_IDLE>"
     5764                    << " / dmiss_req = " << dcache_miss_req
     5765                    << " / imiss_req = " << icache_miss_req
     5766                    << std::endl;
     5767            }
    57945768#endif
    57955769            break;
    … …  
    57985772        case CMD_DATA_WRITE:
    57995773        {
    5800             if ( p_vci.cmdack.read() )
     5774            if (p_vci.cmdack.read())
    58015775            {
    58025776                r_vci_cmd_cpt = r_vci_cmd_cpt + 1;
    58035777                if (r_vci_cmd_cpt == r_vci_cmd_max) // last flit sent
    58045778                {
    5805                     r_vci_cmd_fsm = CMD_IDLE ;
    5806                     r_wbuf.sent() ;
     5779                    r_vci_cmd_fsm = CMD_IDLE;
     5780                    r_wbuf.sent();
    58075781                }
    58085782            }
    … …  
    58145788        {
    58155789            // The CAS and SC VCI commands contain two flits
    5816             if ( p_vci.cmdack.read() )
     5790            if (p_vci.cmdack.read())
    58175791            {
    58185792               r_vci_cmd_cpt = r_vci_cmd_cpt + 1;
    … …  
    58305804        {
    58315805            // all read VCI commands contain one single flit
    5832             if ( p_vci.cmdack.read() ) {
     5806            if (p_vci.cmdack.read()) {
    58335807                r_vci_cmd_fsm = CMD_IDLE;
    58345808            }
    … …  
    58655839    //////////////////////////////////////////////////////////////////////////
    58665840
    5867     switch ( r_vci_rsp_fsm.read() )
     5841    switch (r_vci_rsp_fsm.read())
    58685842    {
    58695843    //////////////
    58705844    case RSP_IDLE:
    58715845    {
    5872         if ( p_vci.rspval.read() )
     5846        if (p_vci.rspval.read())
    58735847        {
    58745848            r_vci_rsp_cpt = 0;
    5875             if (r_dcache_vci_paddr.read() == 0x1f624) std::cout << "Tansaction on barrier, pktid = " <<  p_vci.rpktid.read() << std::endl;
    5876             if      ( (p_vci.rpktid.read() & 0x7) ==  TYPE_DATA_UNC  )
     5849
     5850            if ((p_vci.rpktid.read() & 0x7) ==  TYPE_DATA_UNC)
    58775851            {
    58785852                r_vci_rsp_fsm = RSP_DATA_UNC;
    58795853            }
    5880             else if ( (p_vci.rpktid.read() & 0x7) ==  TYPE_READ_DATA_MISS )
     5854            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_READ_DATA_MISS)
    58815855            {
    58825856                r_vci_rsp_fsm = RSP_DATA_MISS;
    58835857            }
    5884             else if ( (p_vci.rpktid.read() & 0x7) ==  TYPE_READ_INS_UNC   )
     5858            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_READ_INS_UNC)
    58855859            {
    58865860                r_vci_rsp_fsm = RSP_INS_UNC;
    58875861            }
    5888             else if ( (p_vci.rpktid.read() & 0x7) ==  TYPE_READ_INS_MISS  )
     5862            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_READ_INS_MISS)
    58895863            {
    58905864                r_vci_rsp_fsm = RSP_INS_MISS;
    58915865            }
    5892             else if ( (p_vci.rpktid.read() & 0x7) ==  TYPE_WRITE          )
     5866            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_WRITE)
    58935867            {
    58945868                r_vci_rsp_fsm = RSP_DATA_WRITE;
    58955869            }
    5896             else if ( (p_vci.rpktid.read() & 0x7) ==  TYPE_CAS            )
     5870            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_CAS)
    58975871            {
    58985872                r_vci_rsp_fsm = RSP_DATA_UNC;
    58995873            }
    5900             else if ( (p_vci.rpktid.read() & 0x7) ==  TYPE_LL             )
     5874            else if ((p_vci.rpktid.read() & 0x7) ==  TYPE_LL)
    59015875            {
    59025876                r_vci_rsp_fsm = RSP_DATA_LL;
    59035877            }
    5904             else if ( (p_vci.rpktid.read() & 0x7) == TYPE_SC             )
     5878            else if ((p_vci.rpktid.read() & 0x7) == TYPE_SC)
    59055879            {
    59065880                r_vci_rsp_fsm = RSP_DATA_UNC;
    … …  
    59165890        case RSP_INS_MISS:
    59175891        {
    5918             if ( p_vci.rspval.read() )
    5919             {
    5920                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5892            if (p_vci.rspval.read())
     5893            {
     5894                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
    59215895                {
    59225896                    r_vci_rsp_ins_error = true;
    5923                     if ( p_vci.reop.read() ) r_vci_rsp_fsm = RSP_IDLE;
     5897                    if (p_vci.reop.read()) r_vci_rsp_fsm = RSP_IDLE;
    59245898                }
    59255899                else                                        // no error reported
    59265900                {
    5927                     if ( r_vci_rsp_fifo_icache.wok() )
     5901                    if (r_vci_rsp_fifo_icache.wok())
    59285902                    {
    5929                         if ( r_vci_rsp_cpt.read() >= m_icache_words )
     5903                        if (r_vci_rsp_cpt.read() >= m_icache_words)
    59305904                        {
    59315905                            std::cout << "ERROR in VCI_CC_VCACHE " << name()
    … …  
    59345908                            exit(0);
    59355909                        }
    5936                         r_vci_rsp_cpt                 = r_vci_rsp_cpt.read() + 1;
    5937                         vci_rsp_fifo_icache_put       = true,
    5938                         vci_rsp_fifo_icache_data      = p_vci.rdata.read();
    5939                         if ( p_vci.reop.read() )
     5910                        r_vci_rsp_cpt            = r_vci_rsp_cpt.read() + 1;
     5911                        vci_rsp_fifo_icache_put  = true,
     5912                        vci_rsp_fifo_icache_data = p_vci.rdata.read();
     5913                        if (p_vci.reop.read())
    59405914                        {
    5941                             if ( r_vci_rsp_cpt.read() != (m_icache_words - 1) )
     5915                            if (r_vci_rsp_cpt.read() != (m_icache_words - 1))
    59425916                            {
    59435917                                std::cout << "ERROR in VCI_CC_VCACHE " << name()
    … …  
    59465920                                exit(0);
    59475921                            }
    5948                             r_vci_rsp_fsm    = RSP_IDLE;
     5922                            r_vci_rsp_fsm = RSP_IDLE;
    59495923                        }
    59505924                    }
    … …  
    59565930        case RSP_INS_UNC:
    59575931        {
    5958             if (p_vci.rspval.read() )
    5959             {
    5960                 assert( p_vci.reop.read() and
     5932            if (p_vci.rspval.read())
     5933            {
     5934                assert(p_vci.reop.read() and
    59615935                "illegal VCI response packet for uncachable instruction");
    59625936
    5963                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5937                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
    59645938                {
    59655939                    r_vci_rsp_ins_error = true;
    … …  
    59685942                else                                         // no error reported
    59695943                {
    5970                     if ( r_vci_rsp_fifo_icache.wok())
     5944                    if (r_vci_rsp_fifo_icache.wok())
    59715945                    {
    5972                         vci_rsp_fifo_icache_put       = true;
    5973                         vci_rsp_fifo_icache_data      = p_vci.rdata.read();
     5946                        vci_rsp_fifo_icache_put  = true;
     5947                        vci_rsp_fifo_icache_data = p_vci.rdata.read();
    59745948                        r_vci_rsp_fsm = RSP_IDLE;
    59755949                    }
    … …  
    59815955        case RSP_DATA_MISS:
    59825956        {
    5983             if ( p_vci.rspval.read() )
    5984             {
    5985                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5957            if (p_vci.rspval.read())
     5958            {
     5959                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
    59865960                {
    59875961                    r_vci_rsp_data_error = true;
    5988                     if ( p_vci.reop.read() ) r_vci_rsp_fsm = RSP_IDLE;
     5962                    if (p_vci.reop.read()) r_vci_rsp_fsm = RSP_IDLE;
    59895963                }
    59905964                else                                        // no error reported
    59915965                {
    5992 
    5993 
    5994                     if ( r_vci_rsp_fifo_dcache.wok() && r_vci_rsp_fifo_rpktid.wok())
     5966                    if (r_vci_rsp_fifo_dcache.wok() and r_vci_rsp_fifo_rpktid.wok())
    59955967                    {
    5996                         assert( (r_vci_rsp_cpt.read() < m_dcache_words) and
     5968                        assert((r_vci_rsp_cpt.read() < m_dcache_words) and
    59975969                        "The VCI response packet for data miss is too long");
    59985970
    5999                         r_vci_rsp_cpt                 = r_vci_rsp_cpt.read() + 1;
    6000                         vci_rsp_fifo_dcache_put       = true,
    6001                         vci_rsp_fifo_dcache_data      = p_vci.rdata.read();
    6002                         vci_rsp_fifo_rpktid          = (p_vci.rpktid.read() == 0x9);//RWT: interpretation of pktid for state (NCC or CC)
    6003                         vci_rsp_fifo_rpktid_put      = true;//RWT
    6004 
    6005                         if ( p_vci.reop.read() )
     5971                        r_vci_rsp_cpt             = r_vci_rsp_cpt.read() + 1;
     5972                        vci_rsp_fifo_dcache_put   = true,
     5973                        vci_rsp_fifo_dcache_data  = p_vci.rdata.read();
     5974                        vci_rsp_fifo_rpktid       = (p_vci.rpktid.read() == 0x9); //RWT: interpretation of pktid for state (NCC or CC)
     5975                        vci_rsp_fifo_rpktid_put   = true; //RWT
     5976
     5977                        if (p_vci.reop.read())
    60065978                        {
    6007                             if (r_vci_rsp_cpt.read() != m_dcache_words - 1) std::cout << "assert on proc " << name() << std::endl;
    6008                             assert( (r_vci_rsp_cpt.read() == m_dcache_words - 1) and
     5979                            assert((r_vci_rsp_cpt.read() == m_dcache_words - 1) and
    60095980                            "The VCI response packet for data miss is too short");
    60105981
    6011                             r_vci_rsp_fsm     = RSP_IDLE;
     5982                            r_vci_rsp_fsm = RSP_IDLE;
    60125983                        }
    60135984                    }
    … …  
    60195990        case RSP_DATA_UNC:
    60205991        {
    6021             if (p_vci.rspval.read() )
    6022             {
    6023                 assert( p_vci.reop.read() and
     5992            if (p_vci.rspval.read())
     5993            {
     5994                assert(p_vci.reop.read() and
    60245995                "illegal VCI response packet for uncachable read data");
    60255996
    6026                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5997                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
    60275998                {
    60285999                    r_vci_rsp_data_error = true;
    60296000                    r_vci_rsp_fsm = RSP_IDLE;
    60306001                }
    6031                 else                                         // no error reported
    6032                 {
    6033                     if ( r_vci_rsp_fifo_dcache.wok())
     6002                else // no error reported
     6003                {
     6004                    if (r_vci_rsp_fifo_dcache.wok())
    60346005                    {
    6035                         vci_rsp_fifo_dcache_put       = true;
    6036                         vci_rsp_fifo_dcache_data      = p_vci.rdata.read();
     6006                        vci_rsp_fifo_dcache_put  = true;
     6007                        vci_rsp_fifo_dcache_data = p_vci.rdata.read();
    60376008                        r_vci_rsp_fsm = RSP_IDLE;
    60386009                    }
    … …  
    60446015        case RSP_DATA_LL:
    60456016        {
    6046             if ( p_vci.rspval.read() )
    6047             {
    6048                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     6017            if (p_vci.rspval.read())
     6018            {
     6019                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
    60496020                {
    60506021                    r_vci_rsp_data_error = true;
    … …  
    60546025                if (r_vci_rsp_cpt.read() == 0) //first flit
    60556026                {
    6056                     if(r_vci_rsp_fifo_dcache.wok())
     6027                    if (r_vci_rsp_fifo_dcache.wok())
    60576028                    {
    60586029                        assert(!p_vci.reop.read() &&
    … …  
    60666037                else // last flit
    60676038                {
    6068                     if(r_vci_rsp_fifo_dcache.wok())
     6039                    if (r_vci_rsp_fifo_dcache.wok())
    60696040                    {
    60706041                        assert(p_vci.reop.read() &&
    … …  
    60846055            if (p_vci.rspval.read())
    60856056            {
    6086                 assert( p_vci.reop.read() and
     6057                assert(p_vci.reop.read() and
    60876058                "a VCI response packet must contain one flit for a write transaction");
    60886059
    60896060                r_vci_rsp_fsm = RSP_IDLE;
    6090                 uint32_t   wbuf_index = p_vci.rtrdid.read();
     6061                uint32_t wbuf_index = p_vci.rtrdid.read();
    60916062                r_wbuf.completed(wbuf_index);
    6092                 if ( (p_vci.rerror.read()&0x1) != 0 ) r_iss.setWriteBerr();
     6063                if ((p_vci.rerror.read() & 0x1) != 0) r_iss.setWriteBerr();
    60936064            }
    60946065            break;
    … …  
    61036074    // soon as the request has been sent.
    61046075    /////////////////////////////////////////////////////////////////////////////////////
    6105     switch ( r_cc_send_fsm.read() )
     6076    switch (r_cc_send_fsm.read())
    61066077    {
    61076078        ///////////////////////////
    … …  
    61156086            ///////////////////////////////////////////////////////
    61166087            bool update_last_client = r_cc_send_last_client.read();
    6117             if ( r_cc_send_last_client.read() == 0 ) // last client was dcache
     6088            if (r_cc_send_last_client.read() == 0) // last client was dcache
    61186089            {
    61196090                if (r_icache_cc_send_req.read()) // request from icache
    … …  
    61316102            {
    61326103                // the new client is dcache and has a cleanup request
    6133                 if      ( (update_last_client == 0) and
    6134                           (r_dcache_cc_send_type.read() == CC_TYPE_CLEANUP))
     6104                if ((update_last_client == 0) and
     6105                        (r_dcache_cc_send_type.read() == CC_TYPE_CLEANUP))
    61356106                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
    61366107                // the new client is dcache and has a multi acknowledgement request
    6137                 else if ( (update_last_client == 0) and
    6138                           (r_dcache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
     6108                else if ((update_last_client == 0) and
     6109                        (r_dcache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
    61396110                    r_cc_send_fsm = CC_SEND_MULTI_ACK;
    61406111                // the new client is icache and has a cleanup request
    6141                 else if ( (update_last_client == 1) and
    6142                           (r_icache_cc_send_type.read() == CC_TYPE_CLEANUP))
     6112                else if ((update_last_client == 1) and
     6113                        (r_icache_cc_send_type.read() == CC_TYPE_CLEANUP))
    61436114                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
    61446115                // the new client is icache and has a multi acknowledgement request
    6145                 else if ( (update_last_client == 1) and
     6116                else if ((update_last_client == 1) and
    61466117                        (r_icache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
    61476118                    r_cc_send_fsm = CC_SEND_MULTI_ACK;
    … …  
    61656136            {
    61666137
    6167                 if(r_dcache_cc_cleanup_updt_data.read() and (r_cc_send_last_client.read() == 0))//dcache request with data
     6138                if (r_dcache_cc_cleanup_updt_data.read() and
     6139                        (r_cc_send_last_client.read() == 0)) //dcache request with data
    61686140                {
    61696141                    r_cc_send_fsm = CC_SEND_CLEANUP_DATA_UPDT;
    … …  
    61906162            if (p_dspin_p2m.read.read())
    61916163            {
    6192                 if(r_cc_send_data_fifo.rok())
     6164                if (r_cc_send_data_fifo.rok())
    61936165                {
    61946166                    m_cpt_data_cleanup++;
    61956167                    cleanup_data_updt_fifo_dcache_get = true;
    61966168                    r_cc_send_cpt_word = r_cc_send_cpt_word.read() + 1;
    6197                     if (r_cc_send_cpt_word.read() == m_dcache_words-1)
     6169                    if (r_cc_send_cpt_word.read() == m_dcache_words - 1)
    61986170                    {
    61996171                        r_dcache_cc_send_req = false;
    … …  
    62106182        {
    62116183            // wait for the flit to be consumed
    6212             if(p_dspin_p2m.read.read())
    6213             {
    6214                 if(r_cc_send_last_client.read() == 0) // dcache active request
     6184            if (p_dspin_p2m.read.read())
     6185            {
     6186                if (r_cc_send_last_client.read() == 0) // dcache active request
    62156187                    r_dcache_cc_send_req = false; // reset dcache request
    62166188                else // icache active request
    … …  
    62336205    // - CC_BROADCAST  : Broadcast invalidate request (both DCACHE & ICACHE)
    62346206    //////////////////////////////////////////////////////////////////////////////
    6235     switch( r_cc_receive_fsm.read() )
     6207    switch (r_cc_receive_fsm.read())
    62366208    {
    62376209        /////////////////////
    … …  
    62476219                                            DspinRwtParam::M2P_TYPE);
    62486220                // test for a broadcast
    6249                 if (DspinRwtParam::dspin_get(receive_data,DspinRwtParam::M2P_BC))
     6221                if (DspinRwtParam::dspin_get(receive_data, DspinRwtParam::M2P_BC))
    62506222                {
    62516223                    r_cc_receive_fsm = CC_RECEIVE_BRDCAST_HEADER;
    … …  
    62946266                // request dcache to handle the BROADCAST
    62956267                r_cc_receive_dcache_req = true;
    6296                 r_cc_receive_dcache_nline  = DspinRwtParam::dspin_get(receive_data,
     6268                r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data,
    62976269                                             DspinRwtParam::BROADCAST_NLINE);
    62986270                r_cc_receive_dcache_type = CC_TYPE_INVAL;
    62996271                // request icache to handle the BROADCAST
    63006272                r_cc_receive_icache_req = true;
    6301                 r_cc_receive_icache_nline  = DspinRwtParam::dspin_get(receive_data,
     6273                r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data,
    63026274                                             DspinRwtParam::BROADCAST_NLINE);
    63036275                r_cc_receive_icache_type = CC_TYPE_INVAL;
    … …  
    63336305            uint64_t receive_data = p_dspin_m2p.data.read();
    63346306            // for data INVAL, wait for dcache to take the request
    6335             if (p_dspin_m2p.write.read()           and
    6336                 not r_cc_receive_dcache_req.read() )
     6307            if (p_dspin_m2p.write.read() and
     6308                not r_cc_receive_dcache_req.read())
    63376309            {
    63386310                // request dcache to handle the INVAL
    63396311                r_cc_receive_dcache_req = true;
    6340                 r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_INVAL_NLINE);
     6312                r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_INVAL_NLINE);
    63416313                r_cc_receive_dcache_type = CC_TYPE_INVAL;
    63426314                // get back to idle state
    … …  
    63526324            uint64_t receive_data = p_dspin_m2p.data.read();
    63536325            // for ins INVAL, wait for icache to take the request
    6354             if (p_dspin_m2p.write.read()           and
    6355                 not r_cc_receive_icache_req.read() )
     6326            if (p_dspin_m2p.write.read() and
     6327                not r_cc_receive_icache_req.read())
    63566328            {
    63576329                // request icache to handle the INVAL
    63586330                r_cc_receive_icache_req = true;
    6359                 r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_INVAL_NLINE);
     6331                r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_INVAL_NLINE);
    63606332                r_cc_receive_icache_type = CC_TYPE_INVAL;
    63616333                // get back to idle state
    … …  
    63746346            if (not r_cc_receive_dcache_req.read())
    63756347            {
    6376                 r_cc_receive_dcache_updt_tab_idx  = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_UPDT_INDEX);
     6348                r_cc_receive_dcache_updt_tab_idx = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_UPDT_INDEX);
    63776349                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_NLINE;
    63786350                break;
    … …  
    63896361            if (not r_cc_receive_icache_req.read())
    63906362            {
    6391                 r_cc_receive_icache_updt_tab_idx  = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_UPDT_INDEX);
     6363                r_cc_receive_icache_updt_tab_idx = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_UPDT_INDEX);
    63926364                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_NLINE;
    63936365                break;
    … …  
    64036375            // for data INVAL, wait for dcache to take the request and fifo to
    64046376            // be empty
    6405             if ( r_cc_receive_updt_fifo_be.empty() and
    6406                  p_dspin_m2p.write.read() )
    6407             {
    6408                 r_cc_receive_dcache_req = true;
    6409                 r_cc_receive_dcache_nline  = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_NLINE);
    6410                 r_cc_receive_word_idx  = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_WORD_INDEX);
    6411                 r_cc_receive_dcache_type = CC_TYPE_UPDT;
     6377            if (r_cc_receive_updt_fifo_be.empty() and
     6378                 p_dspin_m2p.write.read())
     6379            {
     6380                r_cc_receive_dcache_req   = true;
     6381                r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_NLINE);
     6382                r_cc_receive_word_idx     = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_WORD_INDEX);
     6383                r_cc_receive_dcache_type  = CC_TYPE_UPDT;
    64126384                // get back to idle state
    64136385                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_DATA;
    … …  
    64236395            // for ins INVAL, wait for icache to take the request and fifo to be
    64246396            // empty
    6425             if ( r_cc_receive_updt_fifo_be.empty() and
    6426                  p_dspin_m2p.write.read() )
    6427             {
    6428                 r_cc_receive_icache_req = true;
    6429                 r_cc_receive_icache_nline  = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_NLINE);
    6430                 r_cc_receive_word_idx  = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_WORD_INDEX);
    6431                 r_cc_receive_icache_type = CC_TYPE_UPDT;
     6397            if (r_cc_receive_updt_fifo_be.empty() and
     6398                 p_dspin_m2p.write.read())
     6399            {
     6400                r_cc_receive_icache_req   = true;
     6401                r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_NLINE);
     6402                r_cc_receive_word_idx     = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_WORD_INDEX);
     6403                r_cc_receive_icache_type  = CC_TYPE_UPDT;
    64326404                // get back to idle state
    64336405                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_DATA;
    … …  
    64446416                uint64_t receive_data = p_dspin_m2p.data.read();
    64456417                bool     receive_eop  = p_dspin_m2p.eop.read();
    6446                 cc_receive_updt_fifo_be   = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_BE);
    6447                 cc_receive_updt_fifo_data = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_DATA);
     6418                cc_receive_updt_fifo_be   = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_BE);
     6419                cc_receive_updt_fifo_data = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_DATA);
    64486420                cc_receive_updt_fifo_eop  = receive_eop;
    64496421                cc_receive_updt_fifo_put  = true;
    6450                 if ( receive_eop ) r_cc_receive_fsm = CC_RECEIVE_IDLE;
     6422                if (receive_eop) r_cc_receive_fsm = CC_RECEIVE_IDLE;
    64516423            }
    64526424            break;
    … …  
    64606432                uint64_t receive_data = p_dspin_m2p.data.read();
    64616433                bool     receive_eop  = p_dspin_m2p.eop.read();
    6462                 cc_receive_updt_fifo_be   = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_BE);
    6463                 cc_receive_updt_fifo_data = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_DATA);
     6434                cc_receive_updt_fifo_be   = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_BE);
     6435                cc_receive_updt_fifo_data = DspinRwtParam::dspin_get(receive_data, DspinRwtParam::MULTI_UPDT_DATA);
    64646436                cc_receive_updt_fifo_eop  = receive_eop;
    64656437                cc_receive_updt_fifo_put  = true;
    6466                 if ( receive_eop ) r_cc_receive_fsm = CC_RECEIVE_IDLE;
     6438                if (receive_eop) r_cc_receive_fsm = CC_RECEIVE_IDLE;
    64676439            }
    64686440            break;
    … …  
    64746446
    64756447    uint64_t clack_type = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
    6476                                                      DspinRwtParam::CLACK_TYPE);
    6477 
    6478     size_t clack_way  = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
    6479                                                    DspinRwtParam::CLACK_WAY);
    6480 
    6481     size_t clack_set  = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
    6482                                                    DspinRwtParam::CLACK_SET);
    6483 
    6484     bool dspin_clack_get      = false;
     6448                                                   DspinRwtParam::CLACK_TYPE);
     6449
     6450    size_t clack_way = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
     6451                                                DspinRwtParam::CLACK_WAY);
     6452
     6453    size_t clack_set = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
     6454                                                DspinRwtParam::CLACK_SET);
     6455
     6456    bool dspin_clack_get = false;
    64856457    bool dcache_clack_request = (clack_type == DspinRwtParam::TYPE_CLACK_DATA);
    64866458    bool icache_clack_request = (clack_type == DspinRwtParam::TYPE_CLACK_INST);
    … …  
    64896461    {
    64906462        // CLACK DATA: Send request to DCACHE FSM
    6491         if (dcache_clack_request and not r_dcache_clack_req.read()){
     6463        if (dcache_clack_request and not r_dcache_clack_req.read())
     6464        {
    64926465            r_dcache_clack_req = true;
    6493             r_dcache_clack_way = clack_way & ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
    6494             r_dcache_clack_set = clack_set & ((1ULL<<(uint32_log2(m_dcache_sets)))-1);
     6466            r_dcache_clack_way = clack_way & ((1ULL << (uint32_log2(m_dcache_ways))) - 1);
     6467            r_dcache_clack_set = clack_set & ((1ULL << (uint32_log2(m_dcache_sets))) - 1);
    64956468            dspin_clack_get    = true;
    64966469        }
    64976470
    64986471        // CLACK INST: Send request to ICACHE FSM
    6499         else if (icache_clack_request and not r_icache_clack_req.read()){
     6472        else if (icache_clack_request and not r_icache_clack_req.read())
     6473        {
    65006474            r_icache_clack_req = true;
    65016475            r_icache_clack_way = clack_way & ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
    … …  
    65556529
    65566530    bool is_sc_or_cas  = (r_vci_cmd_fsm.read() == CMD_DATA_CAS) or
    6557                          (r_vci_cmd_fsm.read() == CMD_DATA_SC );
     6531                         (r_vci_cmd_fsm.read() == CMD_DATA_SC);
    65586532
    65596533    p_vci.pktid  = 0;
    … …  
    65656539    p_vci.cfixed = false;
    65666540
    6567     if ( m_monitor_ok ) {
    6568         if ( p_vci.cmdack.read() == true and p_vci.cmdval == true) {
     6541    if (m_monitor_ok) {
     6542        if (p_vci.cmdack.read() == true and p_vci.cmdval == true) {
    65696543            if (((p_vci.address.read()) >= m_monitor_base) and
    6570                 ((p_vci.address.read()) < m_monitor_base + m_monitor_length) ) {
     6544                ((p_vci.address.read()) < m_monitor_base + m_monitor_length)) {
    65716545                std::cout << "CC_VCACHE Monitor " << name() << std::hex
    65726546                          << " Access type = " << vci_cmd_type_str[p_vci.cmd.read()]
    … …  
    65746548                          << " : address = " << p_vci.address.read()
    65756549                          << " / be = " << p_vci.be.read();
    6576                 if ( p_vci.cmd.read() == vci_param::CMD_WRITE ) {
     6550                if (p_vci.cmd.read() == vci_param::CMD_WRITE) {
    65776551                    std::cout << " / data = " << p_vci.wdata.read();
    65786552                }
    … …  
    65826556    }
    65836557
    6584     switch ( r_vci_cmd_fsm.read() ) {
     6558    switch (r_vci_cmd_fsm.read()) {
    65856559
    65866560    case CMD_IDLE:
    … …  
    66836657        p_vci.cmdval  = true;
    66846658        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
    6685         if ( r_vci_cmd_cpt.read() == 0 ) p_vci.wdata = r_dcache_llsc_key.read();
    6686         else                             p_vci.wdata = r_dcache_vci_sc_data.read();
     6659        if (r_vci_cmd_cpt.read() == 0) p_vci.wdata = r_dcache_llsc_key.read();
     6660        else                           p_vci.wdata = r_dcache_vci_sc_data.read();
    66876661        p_vci.be      = 0xF;
    66886662        p_vci.trdid   = 0;
    … …  
    66966670        p_vci.cmdval  = true;
    66976671        p_vci.address = r_dcache_vci_paddr.read() & ~0x3;
    6698         if ( r_vci_cmd_cpt.read() == 0 ) p_vci.wdata = r_dcache_vci_cas_old.read();
    6699         else                             p_vci.wdata = r_dcache_vci_cas_new.read();
     6672        if (r_vci_cmd_cpt.read() == 0) p_vci.wdata = r_dcache_vci_cas_old.read();
     6673        else                           p_vci.wdata = r_dcache_vci_cas_new.read();
    67006674        p_vci.be      = 0xF;
    67016675        p_vci.trdid   = 0;
    … …  
    67106684    // it depends on the VCI_RSP FSM
    67116685
    6712     switch (r_vci_rsp_fsm.read() )
     6686    switch (r_vci_rsp_fsm.read())
    67136687    {
    67146688        case RSP_DATA_WRITE : p_vci.rspack = true; break;
    … …  
    67266700
    67276701    uint64_t dspin_send_data = 0;
    6728     switch ( r_cc_send_fsm.read() )
     6702    switch (r_cc_send_fsm.read())
    67296703    {
    67306704        //////////////////
    … …  
    67396713            // initialize dspin send data
    67406714            DspinRwtParam::dspin_set(dspin_send_data,
    6741                                        m_cc_global_id,
    6742                                        DspinRwtParam::CLEANUP_SRCID);
     6715                                     m_cc_global_id,
     6716                                     DspinRwtParam::CLEANUP_SRCID);
    67436717            DspinRwtParam::dspin_set(dspin_send_data,
    6744                                        0,
    6745                                        DspinRwtParam::P2M_BC);
    6746 
    6747             if(r_cc_send_last_client.read() == 0) // dcache active request
     6718                                     0,
     6719                                     DspinRwtParam::P2M_BC);
     6720
     6721            if (r_cc_send_last_client.read() == 0) // dcache active request
    67486722            {
    67496723                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
    67506724                                >> (m_nline_width - m_x_width - m_y_width)
    67516725                                << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6726
    67526727                DspinRwtParam::dspin_set(dspin_send_data,
    6753                                            dest,
    6754                                            DspinRwtParam::CLEANUP_DEST);
     6728                                         dest,
     6729                                         DspinRwtParam::CLEANUP_DEST);
    67556730
    67566731                DspinRwtParam::dspin_set(dspin_send_data,
    6757                                            (r_dcache_cc_send_nline.read() & 0x300000000ULL)>>32,
    6758                                            DspinRwtParam::CLEANUP_NLINE_MSB);
     6732                                         (r_dcache_cc_send_nline.read() & 0x300000000ULL) >> 32,
     6733                                         DspinRwtParam::CLEANUP_NLINE_MSB);
    67596734
    67606735                DspinRwtParam::dspin_set(dspin_send_data,
    6761                                            r_dcache_cc_send_way.read(),
    6762                                            DspinRwtParam::CLEANUP_WAY_INDEX);
     6736                                         r_dcache_cc_send_way.read(),
     6737                                         DspinRwtParam::CLEANUP_WAY_INDEX);
    67636738
    67646739                DspinRwtParam::dspin_set(dspin_send_data,
    6765                                            DspinRwtParam::TYPE_CLEANUP_DATA,
    6766                                            DspinRwtParam::P2M_TYPE);
     6740                                         DspinRwtParam::TYPE_CLEANUP_DATA,
     6741                                         DspinRwtParam::P2M_TYPE);
    67676742
    67686743                DspinRwtParam::dspin_set(dspin_send_data,
    6769                                            (r_dcache_cc_cleanup_line_ncc.read() and (r_cc_send_last_client.read() == 0)),
    6770                                            DspinRwtParam::CLEANUP_NCC);
     6744                                         (r_dcache_cc_cleanup_line_ncc.read() and (r_cc_send_last_client.read() == 0)),
     6745                                         DspinRwtParam::CLEANUP_NCC);
    67716746            }
    67726747            else                                // icache active request
    … …  
    67776752
    67786753                DspinRwtParam::dspin_set(dspin_send_data,
    6779                                            dest,
    6780                                            DspinRwtParam::CLEANUP_DEST);
     6754                                         dest,
     6755                                         DspinRwtParam::CLEANUP_DEST);
    67816756
    67826757                DspinRwtParam::dspin_set(dspin_send_data,
    6783                                            (r_icache_cc_send_nline.read() & 0x300000000ULL)>>32,
    6784                                            DspinRwtParam::CLEANUP_NLINE_MSB);
     6758                                         (r_icache_cc_send_nline.read() & 0x300000000ULL) >> 32,
     6759                                         DspinRwtParam::CLEANUP_NLINE_MSB);
    67856760
    67866761                DspinRwtParam::dspin_set(dspin_send_data,
    6787                                            r_icache_cc_send_way.read(),
    6788                                            DspinRwtParam::CLEANUP_WAY_INDEX);
     6762                                         r_icache_cc_send_way.read(),
     6763                                         DspinRwtParam::CLEANUP_WAY_INDEX);
    67896764
    67906765                DspinRwtParam::dspin_set(dspin_send_data,
    6791                                            DspinRwtParam::TYPE_CLEANUP_INST,
    6792                                            DspinRwtParam::P2M_TYPE);
     6766                                         DspinRwtParam::TYPE_CLEANUP_INST,
     6767                                         DspinRwtParam::P2M_TYPE);
    67936768
    67946769                DspinRwtParam::dspin_set(dspin_send_data,
    6795                                            0,
    6796                                            DspinRwtParam::CLEANUP_NCC);
     6770                                         0,
     6771                                         DspinRwtParam::CLEANUP_NCC);
    67976772
    67986773
    … …  
    68086783        {
    68096784            // initialize dspin send data
    6810             if(r_cc_send_last_client.read() == 0) // dcache active request
     6785            if (r_cc_send_last_client.read() == 0) // dcache active request
    68116786            {
    68126787                DspinRwtParam::dspin_set(dspin_send_data,
    6813                                            r_dcache_cc_send_nline.read() & 0xFFFFFFFFULL,
    6814                                            DspinRwtParam::CLEANUP_NLINE_LSB);
     6788                                         r_dcache_cc_send_nline.read() & 0xFFFFFFFFULL,
     6789                                         DspinRwtParam::CLEANUP_NLINE_LSB);
    68156790            }
    68166791            else                                  // icache active request
    68176792            {
    68186793                DspinRwtParam::dspin_set(dspin_send_data,
    6819                                            r_icache_cc_send_nline.read() & 0xFFFFFFFFULL,
    6820                                            DspinRwtParam::CLEANUP_NLINE_LSB);
     6794                                         r_icache_cc_send_nline.read() & 0xFFFFFFFFULL,
     6795                                         DspinRwtParam::CLEANUP_NLINE_LSB);
    68216796            }
    68226797            // send flit
    68236798            p_dspin_p2m.data  = dspin_send_data;
    68246799            p_dspin_p2m.write = true;
    6825             p_dspin_p2m.eop   = ! (r_dcache_cc_cleanup_updt_data.read() and (r_cc_send_last_client.read() == 0));
     6800            p_dspin_p2m.eop   = !(r_dcache_cc_cleanup_updt_data.read() and (r_cc_send_last_client.read() == 0));
    68266801            break;
    68276802        }
    … …  
    68316806
    68326807            DspinRwtParam::dspin_set(dspin_send_data,
    6833                                        r_cc_send_data_fifo.read(),
    6834                                        DspinRwtParam::CLEANUP_DATA_UPDT);
    6835 
    6836             p_dspin_p2m.data = dspin_send_data;
     6808                                     r_cc_send_data_fifo.read(),
     6809                                     DspinRwtParam::CLEANUP_DATA_UPDT);
     6810
     6811            p_dspin_p2m.data  = dspin_send_data;
    68376812            p_dspin_p2m.write = true;
    6838             p_dspin_p2m.eop = (r_cc_send_cpt_word.read() == m_dcache_words-1);
     6813            p_dspin_p2m.eop   = (r_cc_send_cpt_word.read() == m_dcache_words - 1);
    68396814            break;
    68406815        }
    … …  
    68446819            // initialize dspin send data
    68456820            DspinRwtParam::dspin_set(dspin_send_data,
    6846                                        0,
    6847                                        DspinRwtParam::P2M_BC);
     6821                                     0,
     6822                                     DspinRwtParam::P2M_BC);
    68486823            DspinRwtParam::dspin_set(dspin_send_data,
    6849                                        DspinRwtParam::TYPE_MULTI_ACK,
    6850                                        DspinRwtParam::P2M_TYPE);
    6851 
    6852             if(r_cc_send_last_client.read() == 0) // dcache active request
     6824                                     DspinRwtParam::TYPE_MULTI_ACK,
     6825                                     DspinRwtParam::P2M_TYPE);
     6826
     6827            if (r_cc_send_last_client.read() == 0) // dcache active request
    68536828            {
    68546829                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
    … …  
    68576832
    68586833                DspinRwtParam::dspin_set(dspin_send_data,
    6859                                            dest,
    6860                                            DspinRwtParam::MULTI_ACK_DEST);
     6834                                         dest,
     6835                                         DspinRwtParam::MULTI_ACK_DEST);
    68616836
    68626837                DspinRwtParam::dspin_set(dspin_send_data,
    6863                                            r_dcache_cc_send_updt_tab_idx.read(),
    6864                                            DspinRwtParam::MULTI_ACK_UPDT_INDEX);
     6838                                         r_dcache_cc_send_updt_tab_idx.read(),
     6839                                         DspinRwtParam::MULTI_ACK_UPDT_INDEX);
    68656840            }
    68666841            else                                    // icache active request
    … …  
    68726847
    68736848                DspinRwtParam::dspin_set(dspin_send_data,
    6874                                            dest,
    6875                                            DspinRwtParam::MULTI_ACK_DEST);
     6849                                         dest,
     6850                                         DspinRwtParam::MULTI_ACK_DEST);
    68766851
    68776852                DspinRwtParam::dspin_set(dspin_send_data,
    6878                                            r_icache_cc_send_updt_tab_idx.read(),
    6879                                            DspinRwtParam::MULTI_ACK_UPDT_INDEX);
     6853                                         r_icache_cc_send_updt_tab_idx.read(),
     6854                                         DspinRwtParam::MULTI_ACK_UPDT_INDEX);
    68806855            }
    68816856            // send flit
    … …  
    68906865    // Receive coherence packets
    68916866    // It depends on the CC_RECEIVE FSM
    6892     switch( r_cc_receive_fsm.read() )
     6867    switch (r_cc_receive_fsm.read())
    68936868    {
    68946869        /////////////////////
    … …  
    69466921        case CC_RECEIVE_INS_UPDT_HEADER:
    69476922        {
    6948             if ( not r_cc_receive_icache_req.read())
     6923            if (not r_cc_receive_icache_req.read())
    69496924                p_dspin_m2p.read = true;
    69506925            else
    … …  
    69566931        case CC_RECEIVE_INS_UPDT_NLINE:
    69576932        {
    6958             if(r_cc_receive_updt_fifo_be.empty())
     6933            if (r_cc_receive_updt_fifo_be.empty())
    69596934                p_dspin_m2p.read = true;
    69606935            else
    … …  
    69766951
    69776952    int clack_type = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
    6978                                                 DspinRwtParam::CLACK_TYPE);
     6953                                              DspinRwtParam::CLACK_TYPE);
    69796954
    69806955    bool dspin_clack_get      = false;
    … …  
    70076982// This version of monitor print both Read and Write request
    70086983{
    7009     m_monitor_ok        = true;
    7010     m_monitor_base      = base;
    7011     m_monitor_length    = length;
     6984    m_monitor_ok     = true;
     6985    m_monitor_base   = base;
     6986    m_monitor_length = length;
    70126987}
    70136988
    70146989tmpl(void)::stop_monitor()
    70156990{
    7016     m_monitor_ok        = false;
     6991    m_monitor_ok = false;
    70176992}
    70186993
Note: See TracChangeset for help on using the changeset viewer.