Ignore:
Timestamp:
Sep 2, 2014, 6:25:53 PM (10 years ago)
Author:
meunier
Message:

MESI branch:

  • Cosmetic
  • Changing counters definitions and tags
  • Renaming dspin_dhccp_param to dspin_hmesi_param
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/MESI/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r719 r785  
    351351            const IntTab        &srcid_x,          // global index on external network
    352352            const IntTab        &tgtid_d,          // global index on direct network
    353             const size_t        cc_global_id,      // global index on cc network
    354353            const size_t        x_width,           // number of x bits in platform
    355354            const size_t        y_width,           // number of x bits in platform
     
    384383        m_sets( nsets ),
    385384        m_words( nwords ),
    386         m_cc_global_id( cc_global_id ),
    387         m_xwidth(x_width),
    388         m_ywidth(y_width),
     385        m_x_width(x_width),
     386        m_y_width(y_width),
    389387        m_debug_start_cycle( debug_start_cycle ),
    390388        m_debug_ok( debug_ok ),
     
    550548            for(seg = m_seglist.begin() ; seg != m_seglist.end() ; seg++)
    551549            {
    552                 if ( seg->special() ) m_seg_config = i;
     550                if (seg->special() ) m_seg_config = i;
    553551                m_seg[i] = & (*seg);
    554552                i++;
    555553            }
     554
     555            addr_t gid = m_seg[0]->baseAddress() >> (vci_param_int::N - x_width - y_width);
     556            m_x_self = (gid >> m_y_width) & ((1 << m_x_width) - 1);
     557            m_y_self =  gid               & ((1 << m_y_width) - 1);
    556558
    557559            // Allocation for IXR_RSP FSM
     
    614616        bool data_change = false;
    615617
    616         if ( entry.state != ENTRY_INVALID )
     618        if (entry.state != ENTRY_INVALID )
    617619        {
    618620            for ( size_t word = 0 ; word<m_words ; word++ )
    619621            {
    620622                m_debug_data[word] = m_cache_data.read(way, set, word);
    621                 if ( (m_debug_previous_valid != ENTRY_INVALID) and
     623                if ((m_debug_previous_valid != ENTRY_INVALID) and
    622624                        (m_debug_data[word] != m_debug_previous_data[word]) )
    623625                {
     
    628630
    629631        // print values if any change
    630         if ( (entry.state != m_debug_previous_valid) or
     632        if ((entry.state != m_debug_previous_valid) or
    631633                ((entry.state != ENTRY_INVALID) and (entry.count != m_debug_previous_count)) or
    632634                ((entry.state != ENTRY_INVALID) and (entry.dirty != m_debug_previous_dirty)) or data_change )
     
    672674    {
    673675        const uint32_t srcid_width = vci_param_int::S;
    674         uint8_t self_x_srcid = m_cc_global_id >> (srcid_width - m_xwidth);
    675         uint8_t self_y_srcid = (m_cc_global_id >> (srcid_width - m_ywidth)) & ((1 << m_xwidth) - 1);
    676 
    677         uint8_t x_srcid = req_srcid >> (srcid_width - m_xwidth);
    678         uint8_t y_srcid = (req_srcid >> (srcid_width - m_ywidth - m_xwidth)) & ((1 << m_xwidth) - 1);
    679         return abs(self_x_srcid - x_srcid) + abs(self_y_srcid - y_srcid);
     676
     677        uint8_t req_x = (req_srcid >> (srcid_width - m_x_width));
     678        uint8_t req_y = (req_srcid >> (srcid_width - m_x_width - m_y_width)) & ((1 << m_y_width) - 1);
     679
     680        return abs(m_x_self - req_x) + abs(m_y_self - req_y);
    680681    }
    681682
     
    706707            // LOCAL
    707708
    708             case MEMC_LOCAL_READ_LO   : rdata = m_cpt_read_miss_local   ; break;
     709            case MEMC_LOCAL_READ_LO   : rdata = m_cpt_read_local   ; break;
    709710            case MEMC_LOCAL_WRITE_LO  : rdata = m_cpt_write_flits_local ; break;
    710711            case MEMC_LOCAL_LL_LO     : rdata = m_cpt_ll_local          ; break;
     
    719720            // REMOTE
    720721
    721             case MEMC_REMOTE_READ_LO  : rdata = m_cpt_read_miss_remote   ; break;
     722            case MEMC_REMOTE_READ_LO  : rdata = m_cpt_read_remote   ; break;
    722723            case MEMC_REMOTE_WRITE_LO : rdata = m_cpt_write_flits_remote ; break;
    723724            case MEMC_REMOTE_LL_LO    : rdata = m_cpt_ll_remote          ; break;
     
    732733            // COST
    733734
    734             case MEMC_COST_READ_LO    : rdata = m_cpt_read_miss_cost ; break;
     735            case MEMC_COST_READ_LO    : rdata = m_cpt_read_cost ; break;
    735736            case MEMC_COST_WRITE_LO   : rdata = m_cpt_write_cost; break;
    736737            case MEMC_COST_LL_LO      : rdata = m_cpt_ll_cost   ; break;
     
    753754            // LOCAL
    754755
    755             case MEMC_LOCAL_MUPDATE_LO  : rdata = m_cpt_update_local ; break;
    756             case MEMC_LOCAL_MINVAL_LO   : rdata = m_cpt_minval_local ; break;
    757             case MEMC_LOCAL_CLEANUP_LO  : rdata = m_cpt_cleanup_local; break;
     756            case MEMC_LOCAL_MUPDATE_LO  : rdata = m_cpt_inval_ro_local; break;
     757            case MEMC_LOCAL_MINVAL_LO   : rdata = m_cpt_minval_local ;  break;
     758            case MEMC_LOCAL_CLEANUP_LO  : rdata = m_cpt_cleanup_local;  break;
    758759            case MEMC_LOCAL_MUPDATE_HI  :
    759760            case MEMC_LOCAL_MINVAL_HI   :
     
    762763            // REMOTE
    763764
    764             case MEMC_REMOTE_MUPDATE_LO : rdata = m_cpt_update_remote ; break;
    765             case MEMC_REMOTE_MINVAL_LO  : rdata = m_cpt_minval_remote ; break;
    766             case MEMC_REMOTE_CLEANUP_LO : rdata = m_cpt_cleanup_remote; break;
     765            case MEMC_REMOTE_MUPDATE_LO : rdata = m_cpt_inval_ro_remote; break;
     766            case MEMC_REMOTE_MINVAL_LO  : rdata = m_cpt_minval_remote ;  break;
     767            case MEMC_REMOTE_CLEANUP_LO : rdata = m_cpt_cleanup_remote;  break;
    767768            case MEMC_REMOTE_MUPDATE_HI :
    768769            case MEMC_REMOTE_MINVAL_HI  :
     
    771772            // COST
    772773
    773             case MEMC_COST_MUPDATE_LO   : rdata = m_cpt_update_cost   ; break;
    774             case MEMC_COST_MINVAL_LO    : rdata = m_cpt_minval_cost   ; break;
    775             case MEMC_COST_CLEANUP_LO   : rdata = m_cpt_cleanup_cost  ; break;
     774            case MEMC_COST_MUPDATE_LO   : rdata = m_cpt_inval_ro_cost; break;
     775            case MEMC_COST_MINVAL_LO    : rdata = m_cpt_minval_cost break;
     776            case MEMC_COST_CLEANUP_LO   : rdata = m_cpt_cleanup_cost; break;
    776777            case MEMC_COST_MUPDATE_HI   :
    777778            case MEMC_COST_MINVAL_HI    :
     
    779780
    780781            // TOTAL
    781 
    782             case MEMC_TOTAL_MUPDATE_LO  : rdata = m_cpt_update ; break;
    783             case MEMC_TOTAL_MINVAL_LO   : rdata = m_cpt_minval ; break;
    784             case MEMC_TOTAL_BINVAL_LO   : rdata = m_cpt_binval ; break;
     782            // inval_ro are equal to the number of requests triggering them
     783            case MEMC_TOTAL_MUPDATE_LO  : rdata = m_cpt_inval_ro_local + m_cpt_inval_ro_remote; break;
     784            case MEMC_TOTAL_MINVAL_LO   : rdata = m_cpt_minval ;  break;
     785            case MEMC_TOTAL_BINVAL_LO   : rdata = m_cpt_binval ;  break;
    785786            case MEMC_TOTAL_MUPDATE_HI  :
    786787            case MEMC_TOTAL_MINVAL_HI   :
     
    788789
    789790            // unknown register
    790 
    791791            default                     : error = 1;
    792792        }
     
    819819            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
    820820
    821         if ( detailed ) m_trt.print(0);
     821        if (detailed ) m_trt.print(0);
    822822    }
    823823
     
    827827    /////////////////////////////////////////
    828828    {
    829         m_cpt_reset_count        = m_cpt_cycles;
    830 
    831         m_cpt_read_miss_local           = 0 ;
    832         m_cpt_read_miss_remote          = 0 ;
    833         m_cpt_read_miss_cost            = 0 ;     
    834                                                                                  
    835         m_cpt_getm_miss_local           = 0 ;     
    836         m_cpt_getm_miss_remote          = 0 ;     
    837                                                                                          
    838         m_cpt_getm_hit_local            = 0 ;     
    839         m_cpt_getm_hit_remote           = 0 ;         
    840         m_cpt_getm_cost                 = 0 ;
    841                                                                                              
    842         m_cpt_write_local               = 0 ;     
    843         m_cpt_write_remote              = 0 ;     
    844         m_cpt_write_flits_local         = 0 ;         
    845         m_cpt_write_flits_remote        = 0 ;         
    846         m_cpt_write_cost                = 0 ;   
    847 
    848         m_cpt_ll_local                  = 0 ;         
    849         m_cpt_ll_remote                 = 0 ;             
    850         m_cpt_ll_cost                   = 0 ;         
    851                                                                                            
    852         m_cpt_sc_local                  = 0 ;                             
    853         m_cpt_sc_remote                 = 0 ;                             
    854         m_cpt_sc_cost                   = 0 ;                             
    855                                                                                          
    856         m_cpt_cas_local                 = 0 ;                                 
    857         m_cpt_cas_remote                = 0 ;                                     
    858         m_cpt_cas_cost                  = 0 ;                                 
    859                                                                                      
    860         m_cpt_update                    = 0 ;                     
    861         m_cpt_update_local              = 0 ;                             
    862         m_cpt_update_remote             = 0 ;                             
    863         m_cpt_update_cost               = 0 ;                         
    864                                                                                    
    865         m_cpt_minval                    = 0 ;                 
    866         m_cpt_minval_local              = 0 ;                         
    867         m_cpt_minval_remote             = 0 ;                     
    868         m_cpt_minval_cost               = 0 ;                         
    869                                                                                      
    870         m_cpt_binval                    = 0 ;                     
    871                                                                                              
    872         m_cpt_cleanup_local             = 0 ;                             
    873         m_cpt_cleanup_remote            = 0 ;                         
    874         m_cpt_cleanup_with_data         = 0 ;                             
    875         m_cpt_cleanup_cost              = 0 ;                         
    876                                                                                      
    877         m_cpt_multi_ack_miss            = 0 ;                         
    878         m_cpt_multi_ack_hit             = 0 ;                     
    879         m_cpt_multi_ack_hit_with_data   = 0 ;                             
    880                                                                                      
    881                                                  
    882         m_cpt_read_miss                 = 0 ;                                     
    883         m_cpt_getm_miss                 = 0 ;                                 
    884         m_cpt_getm_broadcast            = 0 ;                                     
    885         m_cpt_getm_minval               = 0 ;                                     
    886         m_cpt_write_miss                = 0 ;                                             
    887         m_cpt_write_dirty               = 0 ;                                             
    888         m_cpt_write_broadcast           = 0 ;                                                 
    889         m_cpt_write_minval              = 0 ;                                         
    890         m_cpt_cas_broadcast             = 0 ;                                                 
    891         m_cpt_cas_minval                = 0 ;                                                                 
    892         m_cpt_cas_miss                  = 0 ;                                                 
    893                                                                                      
    894         m_cpt_read_locked_rb            = 0 ;                                                                 
    895         m_cpt_cas_locked_rb             = 0 ;                                                                 
    896         m_cpt_write_locked_rb           = 0 ;                                                                                             
    897                                                                                      
    898         m_cpt_trt_rb                    = 0 ;                                                                 
    899         m_cpt_trt_full                  = 0 ;                                                             
    900         m_cpt_put                       = 0 ;                                                             
    901         m_cpt_get                       = 0 ;                                                             
    902         m_cpt_read_fsm_dir_lock         = 0 ;                                                                         
    903         m_cpt_read_fsm_n_dir_lock       = 0 ;                                                                         
    904         m_cpt_write_fsm_dir_lock        = 0 ;                                                                 
    905         m_cpt_write_fsm_n_dir_lock      = 0 ;                                                                                         
    906         m_cpt_xram_rsp_fsm_dir_lock     = 0 ;                                                                             
    907         m_cpt_xram_rsp_fsm_n_dir_lock   = 0 ;                                                                 
    908         m_cpt_cas_fsm_dir_lock          = 0 ;                                                         
    909         m_cpt_cas_fsm_n_dir_lock        = 0 ;                                             
    910         m_cpt_cleanup_fsm_dir_lock      = 0 ;                                                         
    911         m_cpt_cleanup_fsm_n_dir_lock    = 0 ;                                                     
    912         m_cpt_multi_ack_fsm_dir_lock    = 0 ;                                                 
    913         m_cpt_multi_ack_fsm_n_dir_lock  = 0 ;                                                     
    914                                                                                        
    915         m_cpt_dir_unused                = 0 ;                                                             
    916         m_cpt_read_fsm_dir_used         = 0 ;                                                             
    917         m_cpt_write_fsm_dir_used        = 0 ;                                                     
    918         m_cpt_cas_fsm_dir_used          = 0 ;                                             
    919         m_cpt_xram_rsp_fsm_dir_used     = 0 ;                                                 
    920         m_cpt_cleanup_fsm_dir_used      = 0 ;                                                 
    921         m_cpt_multi_ack_fsm_dir_used    = 0 ;                                                         
    922                                                                                                                    
    923         m_cpt_read_fsm_trt_lock         = 0 ;                                                 
    924         m_cpt_write_fsm_trt_lock        = 0 ;                                                         
    925         m_cpt_cas_fsm_trt_lock          = 0 ;                                                         
    926         m_cpt_xram_rsp_fsm_trt_lock     = 0 ;                                                     
    927         m_cpt_ixr_fsm_trt_lock          = 0 ;                                                     
    928                                                                                      
    929         m_cpt_read_fsm_n_trt_lock       = 0 ;                                             
    930         m_cpt_write_fsm_n_trt_lock      = 0 ;                                                         
    931         m_cpt_cas_fsm_n_trt_lock        = 0 ;                                                     
    932         m_cpt_xram_rsp_fsm_n_trt_lock   = 0 ;                                         
    933         m_cpt_ixr_cmd_fsm_n_trt_lock    = 0 ;                                                             
    934         m_cpt_ixr_rsp_fsm_n_trt_lock    = 0 ;                                                     
    935                                                                                      
    936         m_cpt_read_fsm_trt_used         = 0 ;                                                     
    937         m_cpt_write_fsm_trt_used        = 0 ;                                                         
    938         m_cpt_cas_fsm_trt_used          = 0 ;                                             
    939         m_cpt_xram_rsp_fsm_trt_used     = 0 ;                                                     
    940         m_cpt_ixr_cmd_fsm_trt_used      = 0 ;                                                 
    941         m_cpt_ixr_rsp_fsm_trt_used      = 0 ;                                                     
    942         m_cpt_cleanup_fsm_trt_used      = 0 ;                                             
    943                                                                                                              
    944         m_cpt_trt_unused                = 0 ;                                                 
    945                                                                                    
    946         m_cpt_cleanup_fsm_ivt_lock      = 0 ;                                             
    947         m_cpt_cleanup_fsm_n_ivt_lock    = 0 ;                                                         
    948                                                                                      
    949         m_cpt_multi_ack_fsm_ivt_lock    = 0 ;                                                 
    950         m_cpt_multi_ack_fsm_n_ivt_lock  = 0 ;                                             
    951                                                                                    
    952         m_cpt_ivt_unused                = 0 ;                             
    953                                                                                      
    954         m_cpt_read_fsm_heap_lock        = 0 ;                                                     
    955         m_cpt_write_fsm_heap_lock       = 0 ;                                                 
    956         m_cpt_cas_fsm_heap_lock         = 0 ;                                             
    957         m_cpt_cleanup_fsm_heap_lock     = 0 ;                                                         
    958         m_cpt_xram_rsp_fsm_heap_lock    = 0 ;                                                             
    959         m_cpt_multi_ack_fsm_heap_lock   = 0 ;                                                 
    960                                                                                    
    961         m_cpt_read_fsm_n_heap_lock      = 0 ;                                                 
    962         m_cpt_write_fsm_n_heap_lock     = 0 ;                                             
    963         m_cpt_cas_fsm_n_heap_lock       = 0 ;                                                     
    964         m_cpt_cleanup_fsm_n_heap_lock   = 0 ;                                                     
    965         m_cpt_xram_rsp_fsm_n_heap_lock  = 0 ;                                                         
    966         m_cpt_multi_ack_fsm_n_heap_lock = 0 ;                                                         
    967                                                                                                                  
    968         m_cpt_read_fsm_heap_used        = 0 ;                                                 
    969         m_cpt_write_fsm_heap_used       = 0 ;                                                 
    970         m_cpt_cas_fsm_heap_used         = 0 ;                                             
    971         m_cpt_cleanup_fsm_heap_used     = 0 ;                                         
    972         m_cpt_xram_rsp_fsm_heap_used    = 0 ;                                         
    973         m_cpt_multi_ack_fsm_heap_used   = 0 ;                                                     
    974                                                                                      
    975         m_cpt_heap_unused               = 0 ;                     
    976         m_cpt_slot_inval                = 0 ;
    977    
     829        m_cpt_reset_count               = m_cpt_cycles;
     830
     831        m_cpt_read_local                = 0;
     832        m_cpt_read_remote               = 0;
     833        m_cpt_read_cost                 = 0;
     834
     835        m_cpt_write_local               = 0;
     836        m_cpt_write_remote              = 0;
     837        m_cpt_write_flits_local         = 0;
     838        m_cpt_write_flits_remote        = 0;
     839        m_cpt_write_cost                = 0;
     840
     841        m_cpt_ll_local                  = 0;
     842        m_cpt_ll_remote                 = 0;
     843        m_cpt_ll_cost                   = 0;
     844
     845        m_cpt_sc_local                  = 0;
     846        m_cpt_sc_remote                 = 0;
     847        m_cpt_sc_cost                   = 0;
     848
     849        m_cpt_cas_local                 = 0;
     850        m_cpt_cas_remote                = 0;
     851        m_cpt_cas_cost                  = 0;
     852
     853        m_cpt_minval                    = 0;
     854        m_cpt_minval_local              = 0;
     855        m_cpt_minval_remote             = 0;
     856        m_cpt_minval_cost               = 0;
     857
     858        m_cpt_binval                    = 0;
     859        m_cpt_write_broadcast           = 0;
     860        m_cpt_getm_broadcast            = 0;
     861
     862        m_cpt_cleanup_local             = 0;
     863        m_cpt_cleanup_remote            = 0;
     864        m_cpt_cleanup_cost              = 0;
     865        m_cpt_cleanup_data_local        = 0;
     866        m_cpt_cleanup_data_remote       = 0;
     867        m_cpt_cleanup_data_cost         = 0;
     868
     869        m_cpt_read_miss                 = 0;
     870        m_cpt_write_miss                = 0;
     871        m_cpt_write_dirty               = 0;
     872        m_cpt_getm_miss                 = 0;
     873
     874        m_cpt_getm_local                = 0;
     875        m_cpt_getm_remote               = 0;
     876        m_cpt_getm_cost                 = 0;
     877
     878        m_cpt_inval_ro_local            = 0;
     879        m_cpt_inval_ro_remote           = 0;
     880        m_cpt_inval_ro_cost             = 0;
     881
     882        m_cpt_trt_rb                    = 0;
     883        m_cpt_trt_full                  = 0;
     884        m_cpt_put                       = 0;
     885        m_cpt_get                       = 0;
     886
     887        m_cpt_heap_unused               = 0;
     888        m_cpt_slot_inval                = 0;
    978889    }
    979890
    980891
    981892    /////////////////////////////////////////
    982     tmpl(void)::print_stats(bool activity_counters = true, bool stats = true)
     893    tmpl(void)::print_stats(bool activity_counters)
    983894    {
    984895        std::cout << "**********************************" << std::dec << std::endl;
     
    993904                << "[001] NUMBER OF CYCLES          = " << m_cpt_cycles << std::endl
    994905                << std::endl
    995                 << "[002] LOCAL READ                = " << m_cpt_read_miss_local << std::endl
    996                 << "[003] REMOTE READ               = " << m_cpt_read_miss_remote << std::endl
    997                 << "[004] READ COST (FLITS * DIST)  = " << m_cpt_read_miss_cost << std::endl
     906                << "[010] LOCAL READ                = " << m_cpt_read_local << std::endl
     907                << "[011] REMOTE READ               = " << m_cpt_read_remote << std::endl
     908                << "[012] READ COST (FLITS * DIST)  = " << m_cpt_read_cost << std::endl
    998909                << std::endl
    999                 << "[005] LOCAL WRITE               = " << m_cpt_write_local << std::endl
    1000                 << "[006] REMOTE WRITE              = " << m_cpt_write_remote << std::endl
    1001                 << "[007] WRITE FLITS LOCAL         = " << m_cpt_write_flits_local << std::endl
    1002                 << "[008] WRITE FLITS REMOTE        = " << m_cpt_write_flits_remote << std::endl
    1003                 << "[009] WRITE COST (FLITS * DIST) = " << m_cpt_write_cost << std::endl
     910                << "[020] LOCAL WRITE               = " << m_cpt_write_local << std::endl
     911                << "[021] REMOTE WRITE              = " << m_cpt_write_remote << std::endl
     912                << "[022] WRITE FLITS LOCAL         = " << m_cpt_write_flits_local << std::endl
     913                << "[023] WRITE FLITS REMOTE        = " << m_cpt_write_flits_remote << std::endl
     914                << "[024] WRITE COST (FLITS * DIST) = " << m_cpt_write_cost << std::endl
     915                << "[025] WRITE L1 MISS NCC         = " << "0" << std::endl
    1004916                << std::endl
    1005                 << "[010] LOCAL LL                  = " << m_cpt_ll_local << std::endl
    1006                 << "[011] REMOTE LL                 = " << m_cpt_ll_remote << std::endl
    1007                 << "[012] LL COST (FLITS * DIST)    = " << m_cpt_ll_cost << std::endl
     917                << "[030] LOCAL LL                  = " << m_cpt_ll_local << std::endl
     918                << "[031] REMOTE LL                 = " << m_cpt_ll_remote << std::endl
     919                << "[032] LL COST (FLITS * DIST)    = " << m_cpt_ll_cost << std::endl
    1008920                << std::endl
    1009                 << "[013] LOCAL SC                  = " << m_cpt_sc_local << std::endl
    1010                 << "[014] REMOTE SC                 = " << m_cpt_sc_remote << std::endl
    1011                 << "[015] SC COST (FLITS * DIST)    = " << m_cpt_sc_cost << std::endl
     921                << "[040] LOCAL SC                  = " << m_cpt_sc_local << std::endl
     922                << "[041] REMOTE SC                 = " << m_cpt_sc_remote << std::endl
     923                << "[042] SC COST (FLITS * DIST)    = " << m_cpt_sc_cost << std::endl
    1012924                << std::endl
    1013                 << "[016] LOCAL CAS                 = " << m_cpt_cas_local << std::endl
    1014                 << "[017] REMOTE CAS                = " << m_cpt_cas_remote << std::endl
    1015                 << "[018] CAS COST (FLITS * DIST)   = " << m_cpt_cas_cost << std::endl
     925                << "[050] LOCAL CAS                 = " << m_cpt_cas_local << std::endl
     926                << "[051] REMOTE CAS                = " << m_cpt_cas_remote << std::endl
     927                << "[052] CAS COST (FLITS * DIST)   = " << m_cpt_cas_cost << std::endl
    1016928                << std::endl
    1017                 << "[019] REQUESTS TRIG. UPDATE     = " << m_cpt_update << std::endl
    1018                 << "[020] LOCAL UPDATE              = " << m_cpt_update_local << std::endl
    1019                 << "[021] REMOTE UPDATE             = " << m_cpt_update_remote << std::endl
    1020                 << "[022] UPDT COST (FLITS * DIST)  = " << m_cpt_update_cost << std::endl
     929                << "[060] REQUESTS TRIG. UPDATE     = " << "0" << std::endl
     930                << "[061] LOCAL UPDATE              = " << "0" << std::endl
     931                << "[062] REMOTE UPDATE             = " << "0" << std::endl
     932                << "[063] UPDT COST (FLITS * DIST)  = " << "0" << std::endl
    1021933                << std::endl
    1022                 << "[023] REQUESTS TRIG. M_INV      = " << m_cpt_minval << std::endl
    1023                 << "[024] LOCAL M_INV               = " << m_cpt_minval_local << std::endl
    1024                 << "[025] REMOTE M_INV              = " << m_cpt_minval_remote << std::endl
    1025                 << "[026] M_INV COST (FLITS * DIST) = " << m_cpt_minval_cost << std::endl
     934                << "[070] REQUESTS TRIG. M_INV      = " << m_cpt_minval << std::endl
     935                << "[071] LOCAL M_INV               = " << m_cpt_minval_local << std::endl
     936                << "[072] REMOTE M_INV              = " << m_cpt_minval_remote << std::endl
     937                << "[073] M_INV COST (FLITS * DIST) = " << m_cpt_minval_cost << std::endl
    1026938                << std::endl
    1027                 << "[027] BROADCAT INVAL            = " << m_cpt_binval << std::endl
     939                << "[080] BROADCAT INVAL            = " << m_cpt_binval << std::endl
     940                << "[081] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     941                << "[082] GETM BROADCAST            = " << m_cpt_getm_broadcast << std::endl
    1028942                << std::endl
    1029                 << "[028] LOCAL CLEANUP             = " << m_cpt_cleanup_local << std::endl
    1030                 << "[029] REMOTE CLEANUP            = " << m_cpt_cleanup_remote << std::endl
    1031                 << "[030] CLNUP COST (FLITS * DIST) = " << m_cpt_cleanup_cost << std::endl
     943                << "[090] LOCAL CLEANUP             = " << m_cpt_cleanup_local << std::endl
     944                << "[091] REMOTE CLEANUP            = " << m_cpt_cleanup_remote << std::endl
     945                << "[092] CLNUP COST (FLITS * DIST) = " << m_cpt_cleanup_cost << std::endl
     946                << "[093] LOCAL CLEANUP DATA        = " << m_cpt_cleanup_data_local << std::endl
     947                << "[094] REMOTE CLEANUP DATA       = " << m_cpt_cleanup_data_remote << std::endl
     948                << "[095] CLEANUP DATA COST         = " << m_cpt_cleanup_data_cost << std::endl
    1032949                << std::endl
     950                << "[100] READ MISS                 = " << m_cpt_read_miss << std::endl
     951                << "[101] WRITE MISS                = " << m_cpt_write_miss << std::endl
     952                << "[102] WRITE DIRTY               = " << m_cpt_write_dirty << std::endl
     953                << "[103] GETM MISS                 = " << m_cpt_getm_miss << std::endl
    1033954                << std::endl
    1034                 << "[031] READ MISS                 = " << m_cpt_read_miss << std::endl
    1035                 << "[032] WRITE MISS                = " << m_cpt_write_miss << std::endl
    1036                 << "[033] WRITE DIRTY               = " << m_cpt_write_dirty << std::endl
    1037                 << "[034] RD BLOCKED BY HIT IN TRT  = " << m_cpt_trt_rb << std::endl
    1038                 << "[035] TRANS BLOCKED BY FULL TRT = " << m_cpt_trt_full << std::endl
    1039                 << "[036] PUT (UNIMPLEMENTED)       = " << m_cpt_put << std::endl
    1040                 << "[037] GET (UNIMPLEMENTED)       = " << m_cpt_get << std::endl
    1041                 << "[038] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     955                << "[110] RD BLOCKED BY HIT IN TRT  = " << m_cpt_trt_rb << std::endl
     956                << "[111] TRANS BLOCKED BY FULL TRT = " << m_cpt_trt_full << std::endl
     957                << "[120] PUT (UNIMPLEMENTED)       = " << m_cpt_put << std::endl
     958                << "[121] GET (UNIMPLEMENTED)       = " << m_cpt_get << std::endl
     959                << "[130] MIN HEAP SLOT AVAILABLE   = " << "-1" << std::endl
    1042960                << std::endl
    1043 
     961                << "[140] NCC TO CC (READ)          = " << "0" << std::endl
     962                << "[141] NCC TO CC (WRITE)         = " << "0" << std::endl
     963                << std::endl
     964                << "[150] LOCAL GETM                = " << m_cpt_getm_local << std::endl
     965                << "[151] REMOTE GETM               = " << m_cpt_getm_remote << std::endl
     966                << "[152] GETM COST (FLITS * DIST)  = " << m_cpt_getm_cost << std::endl
     967                << std::endl
     968                << "[160] LOCAL INVAL RO            = " << m_cpt_inval_ro_local << std::endl
     969                << "[161] REMOTE INVAL RO           = " << m_cpt_inval_ro_remote << std::endl
     970                << "[162] INVAL RO COST             = " << m_cpt_inval_ro_cost << std::endl
     971                << std::endl;
     972
     973#if 0
    1044974                << "[050] LOCAL GETM MISS           = " << m_cpt_getm_miss_local << std::endl
    1045975                << "[051] REMOTE GETM MISS          = " << m_cpt_getm_miss_remote << std::endl
     
    1047977                << "[053] REMOTE GETM HIT           = " << m_cpt_getm_hit_remote << std::endl
    1048978                << "[054] GETM COST (FLITS * DIST)  = " << m_cpt_getm_cost << std::endl
    1049                 << std::endl
    1050                 << "[055] CLEANUP WITH DATA         = " << m_cpt_cleanup_with_data << std::endl
    1051979                << std::endl
    1052980                << "[056] MULTI_ACK_MISS            = " << m_cpt_multi_ack_miss << std::endl
     
    1064992                << "[066] EVICTED SLOT              = " << m_cpt_slot_inval << std::endl
    1065993                << std::endl;
     994#endif
    1066995        }
    1067996
    1068         if (stats) {
    1069             std::cout << "----------------------------------" << std::dec << std::endl;
    1070             std::cout << "---      Calculated Stats      ---" << std::dec << std::endl;
    1071             std::cout << "----------------------------------" << std::dec << std::endl;
    1072             std::cout
    1073                 << "[100] READ TOTAL            = " << m_cpt_read_miss_local + m_cpt_read_miss_remote << std::endl
    1074                 << "[101] READ RATE             = " << (double) (m_cpt_read_miss_local + m_cpt_read_miss_remote) / m_cpt_cycles << std::endl
    1075                 << "[102] LOCAL READ RATE       = " << (double) m_cpt_read_miss_local / m_cpt_cycles << std::endl
    1076                 << "[103] REMOTE READ RATE      = " << (double) m_cpt_read_miss_remote / m_cpt_cycles << std::endl
    1077                 << "[104] READ MISS RATE        = " << (double) m_cpt_read_miss / (m_cpt_read_miss_local + m_cpt_read_miss_remote) << std::endl
    1078                 << "[105] GETM MISS TOTAL       = " << m_cpt_getm_miss_local + m_cpt_getm_miss_remote << std::endl
    1079                 << "[106] GETM MISS RATE        = " << (double) (m_cpt_getm_miss_local + m_cpt_getm_miss_remote) / m_cpt_cycles << std::endl
    1080                 << "[107] LOCAL GETM MISS RATE  = " << (double) m_cpt_getm_miss_local / m_cpt_cycles << std::endl
    1081                 << "[108] REMOTE GETM MISS RATE = " << (double) m_cpt_getm_miss_remote / m_cpt_cycles << std::endl
    1082                 << "[109] GETM HIT TOTAL        = " << m_cpt_getm_hit_local + m_cpt_getm_hit_remote << std::endl
    1083                 << "[110] GETM HIT RATE         = " << (double) (m_cpt_getm_hit_local + m_cpt_getm_hit_remote) / m_cpt_cycles << std::endl
    1084                 << "[111] LOCAL GETM HIT RATE   = " << (double) m_cpt_getm_hit_local / m_cpt_cycles << std::endl
    1085                 << "[112] REMOTE GETM HIT RATE  = " << (double) m_cpt_getm_hit_remote / m_cpt_cycles << std::endl
    1086 
    1087                 << "[113] GETM TOTAL            = " << m_cpt_getm_hit_local + m_cpt_getm_hit_remote + m_cpt_getm_miss_remote + m_cpt_getm_miss_local << std::endl
    1088 
    1089                 << "[114] GETM MISS RATE        = " << (double) m_cpt_read_miss / (m_cpt_getm_hit_local + m_cpt_getm_hit_remote + m_cpt_getm_miss_remote + m_cpt_getm_miss_local) << std::endl
    1090  
    1091                 << std::endl
    1092                 << "[115] WRITE TOTAL           = " << m_cpt_write_local + m_cpt_write_remote << std::endl
    1093                 << "[116] WRITE RATE            = " << (double) (m_cpt_write_local + m_cpt_write_remote) / m_cpt_cycles << std::endl
    1094                 << "[117] LOCAL WRITE RATE      = " << (double) m_cpt_write_local / m_cpt_cycles << std::endl
    1095                 << "[118] REMOTE WRITE RATE     = " << (double) m_cpt_write_remote / m_cpt_cycles << std::endl
    1096                 << "[119] WRITE MISS RATE       = " << (double) m_cpt_write_miss / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1097                 << "[120] WRITE BURST TOTAL     = " << m_cpt_write_flits_local + m_cpt_write_flits_remote << std::endl
    1098                 << "[121] WRITE BURST AVERAGE   = " << (double) (m_cpt_write_flits_local + m_cpt_write_flits_remote) / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1099                 << "[122] LOCAL WRITE BURST AV. = " << (double) m_cpt_write_flits_local / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1100                 << "[123] REMOTE WRITE BURST AV = " << (double) m_cpt_write_flits_remote / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1101                 << std::endl
    1102                 << "[124] UPDATE RATE                = " << (double) m_cpt_update / m_cpt_cycles << std::endl
    1103                 << "[125] AV. UPDATE PER UP REQ      = " << (double) (m_cpt_update_local + m_cpt_update_remote) / m_cpt_update << std::endl
    1104                 << "[126] AV. LOC UPDT PER UP REQ    = " << (double) m_cpt_update_local / m_cpt_update << std::endl
    1105                 << "[127] AV. REMOTE UPDT PER UP REQ = " << (double) m_cpt_update_remote / m_cpt_update << std::endl
    1106                 << std::endl
    1107                 << "[128] INVAL MULTICAST RATE  = " << (double) m_cpt_minval / m_cpt_cycles << std::endl
    1108                 << "[129] AVE. INVAL PER M_INV  = " << (double) (m_cpt_minval_local + m_cpt_minval_remote) / m_cpt_minval << std::endl
    1109                 << "[130] AV. LOC INV PER M_INV = " << (double) m_cpt_minval_local / m_cpt_minval << std::endl
    1110                 << "[131] AV. REM INV PER M_INV = " << (double) m_cpt_minval_remote / m_cpt_minval << std::endl
    1111                 << std::endl
    1112                 << "[132] INVAL BROADCAST RATE  = " << (double) m_cpt_binval / m_cpt_cycles << std::endl
    1113                 << "[133] WRITE DIRTY RATE      = " << (double) m_cpt_write_dirty / m_cpt_cycles << std::endl
    1114                 << std::endl
    1115                 << "[134] CLEANUP RATE          = " << (double) (m_cpt_cleanup_local + m_cpt_cleanup_remote) / m_cpt_cycles << std::endl
    1116                 << "[135] LOCAL CLEANUP RATE    = " << (double) m_cpt_cleanup_local / m_cpt_cycles << std::endl
    1117                 << "[136] REMOTE CLEANUP RATE   = " << (double) m_cpt_cleanup_remote / m_cpt_cycles << std::endl
    1118                 << "[137] LL RATE               = " << (double) (m_cpt_ll_local + m_cpt_ll_remote) / m_cpt_cycles << std::endl
    1119                 << "[138] LOCAL LL RATE         = " << (double) m_cpt_ll_local / m_cpt_cycles << std::endl
    1120                 << "[139] REMOTE LL RATE        = " << (double) m_cpt_ll_remote / m_cpt_cycles << std::endl
    1121                 << "[140] SC RATE               = " << (double) (m_cpt_sc_local + m_cpt_sc_remote) / m_cpt_cycles << std::endl
    1122                 << "[141] LOCAL SC RATE         = " << (double) m_cpt_sc_local / m_cpt_cycles << std::endl
    1123                 << "[142] REMOTE SC RATE        = " << (double) m_cpt_sc_remote / m_cpt_cycles << std::endl
    1124                 << "[143] CAS RATE              = " << (double) (m_cpt_cas_local + m_cpt_cas_remote) / m_cpt_cycles << std::endl
    1125                 << "[144] LOCAL CAS RATE        = " << (double) m_cpt_cas_local / m_cpt_cycles << std::endl
    1126                 << "[145] REMOTE CAS RATE       = " << (double) m_cpt_cas_remote / m_cpt_cycles << std::endl
    1127                 << "[124] MULTI ACK RATE        = " << (double) (m_cpt_multi_ack_hit + m_cpt_multi_ack_miss) / m_cpt_cycles << std::endl
    1128                 << std::endl;
    1129         }
     997        // No more calculated stats
    1130998    }
    1131999
    11321000
    11331001    /////////////////////////////////
    1134     tmpl(/**/) ::~VciMemCache()
    1135         /////////////////////////////////
     1002    tmpl(/**/)::~VciMemCache()
     1003    /////////////////////////////////
    11361004    {
    11371005        delete [] m_seg;
     
    11681036    //////////////////////////////////
    11691037    tmpl(void) ::transition()
    1170         //////////////////////////////////
     1038    //////////////////////////////////
    11711039    {
    11721040        using soclib::common::uint32_log2;
    11731041
    11741042        // RESET
    1175         if(! p_resetn.read())
     1043        if (! p_resetn.read())
    11761044        {
    11771045
     
    13171185
    13181186            // Activity counters
    1319             m_cpt_reset_count               = 0 ;                   
    1320             m_cpt_read_miss_local           = 0 ;
    1321             m_cpt_read_miss_remote          = 0 ;
    1322             m_cpt_read_miss_cost            = 0 ;     
    1323                                                                                      
    1324             m_cpt_getm_miss_local           = 0 ;     
    1325             m_cpt_getm_miss_remote          = 0 ;     
    1326                                                                                              
    1327             m_cpt_getm_hit_local            = 0 ;     
    1328             m_cpt_getm_hit_remote           = 0 ;         
    1329             m_cpt_getm_cost                 = 0 ;
    1330                                                                                                  
    1331             m_cpt_write_local               = 0 ;     
    1332             m_cpt_write_remote              = 0 ;     
    1333             m_cpt_write_flits_local         = 0 ;         
    1334             m_cpt_write_flits_remote        = 0 ;         
    1335             m_cpt_write_cost                = 0 ;   
    1336 
    1337             m_cpt_ll_local                  = 0 ;         
    1338             m_cpt_ll_remote                 = 0 ;             
    1339             m_cpt_ll_cost                   = 0 ;         
    1340                                                                                                
    1341             m_cpt_sc_local                  = 0 ;                             
    1342             m_cpt_sc_remote                 = 0 ;                             
    1343             m_cpt_sc_cost                   = 0 ;                             
    1344                                                                                              
    1345             m_cpt_cas_local                 = 0 ;                                 
    1346             m_cpt_cas_remote                = 0 ;                                     
    1347             m_cpt_cas_cost                  = 0 ;                                 
    1348                                                                                          
    1349             m_cpt_update                    = 0 ;                     
    1350             m_cpt_update_local              = 0 ;                             
    1351             m_cpt_update_remote             = 0 ;                             
    1352             m_cpt_update_cost               = 0 ;                         
    1353                                                                                        
    1354             m_cpt_minval                    = 0 ;                 
    1355             m_cpt_minval_local              = 0 ;                         
    1356             m_cpt_minval_remote             = 0 ;                     
    1357             m_cpt_minval_cost               = 0 ;                         
    1358                                                                                          
    1359             m_cpt_binval                    = 0 ;                     
    1360                                                                                                  
    1361             m_cpt_cleanup_local             = 0 ;                             
    1362             m_cpt_cleanup_remote            = 0 ;                         
    1363             m_cpt_cleanup_with_data         = 0 ;                             
    1364             m_cpt_cleanup_cost              = 0 ;                         
    1365                                                                                          
    1366             m_cpt_multi_ack_miss            = 0 ;                         
    1367             m_cpt_multi_ack_hit             = 0 ;                     
    1368             m_cpt_multi_ack_hit_with_data   = 0 ;                             
    1369                                                                                          
    1370                                                      
    1371             m_cpt_read_miss                 = 0 ;                                     
    1372             m_cpt_getm_miss                 = 0 ;                                 
    1373             m_cpt_getm_broadcast            = 0 ;                                     
    1374             m_cpt_getm_minval               = 0 ;                                     
    1375             m_cpt_write_miss                = 0 ;                                             
    1376             m_cpt_write_dirty               = 0 ;                                             
    1377             m_cpt_write_broadcast           = 0 ;                                                 
    1378             m_cpt_write_minval              = 0 ;                                         
    1379             m_cpt_cas_broadcast             = 0 ;                                                 
    1380             m_cpt_cas_minval                = 0 ;                                                                 
    1381             m_cpt_cas_miss                  = 0 ;                                                 
    1382                                                                                          
    1383             m_cpt_read_locked_rb            = 0 ;                                                                 
    1384             m_cpt_cas_locked_rb             = 0 ;                                                                 
    1385             m_cpt_write_locked_rb           = 0 ;                                                                                             
    1386                                                                                          
    1387             m_cpt_trt_rb                    = 0 ;                                                                 
    1388             m_cpt_trt_full                  = 0 ;                                                             
    1389             m_cpt_put                       = 0 ;                                                             
    1390             m_cpt_get                       = 0 ;                                                             
    1391                                                                                              
    1392             m_cpt_read_fsm_dir_lock         = 0 ;                                                                         
    1393             m_cpt_read_fsm_n_dir_lock       = 0 ;                                                                         
    1394             m_cpt_write_fsm_dir_lock        = 0 ;                                                                 
    1395             m_cpt_write_fsm_n_dir_lock      = 0 ;                                                                                         
    1396             m_cpt_xram_rsp_fsm_dir_lock     = 0 ;                                                                             
    1397             m_cpt_xram_rsp_fsm_n_dir_lock   = 0 ;                                                                 
    1398             m_cpt_cas_fsm_dir_lock          = 0 ;                                                         
    1399             m_cpt_cas_fsm_n_dir_lock        = 0 ;                                             
    1400             m_cpt_cleanup_fsm_dir_lock      = 0 ;                                                         
    1401             m_cpt_cleanup_fsm_n_dir_lock    = 0 ;                                                     
    1402             m_cpt_multi_ack_fsm_dir_lock    = 0 ;                                                 
    1403             m_cpt_multi_ack_fsm_n_dir_lock  = 0 ;                                                     
    1404                                                                                            
    1405             m_cpt_dir_unused                = 0 ;                                                             
    1406             m_cpt_read_fsm_dir_used         = 0 ;                                                             
    1407             m_cpt_write_fsm_dir_used        = 0 ;                                                     
    1408             m_cpt_cas_fsm_dir_used          = 0 ;                                             
    1409             m_cpt_xram_rsp_fsm_dir_used     = 0 ;                                                 
    1410             m_cpt_cleanup_fsm_dir_used      = 0 ;                                                 
    1411             m_cpt_multi_ack_fsm_dir_used    = 0 ;                                                         
    1412                                                                                                                        
    1413             m_cpt_read_fsm_trt_lock         = 0 ;                                                 
    1414             m_cpt_write_fsm_trt_lock        = 0 ;                                                         
    1415             m_cpt_cas_fsm_trt_lock          = 0 ;                                                         
    1416             m_cpt_xram_rsp_fsm_trt_lock     = 0 ;                                                     
    1417             m_cpt_ixr_fsm_trt_lock          = 0 ;                                                     
    1418                                                                                          
    1419             m_cpt_read_fsm_n_trt_lock       = 0 ;                                             
    1420             m_cpt_write_fsm_n_trt_lock      = 0 ;                                                         
    1421             m_cpt_cas_fsm_n_trt_lock        = 0 ;                                                     
    1422             m_cpt_xram_rsp_fsm_n_trt_lock   = 0 ;                                         
    1423             m_cpt_ixr_cmd_fsm_n_trt_lock    = 0 ;                                                             
    1424             m_cpt_ixr_rsp_fsm_n_trt_lock    = 0 ;                                                     
    1425                                                                                          
    1426             m_cpt_read_fsm_trt_used         = 0 ;                                                     
    1427             m_cpt_write_fsm_trt_used        = 0 ;                                                         
    1428             m_cpt_cas_fsm_trt_used          = 0 ;                                             
    1429             m_cpt_xram_rsp_fsm_trt_used     = 0 ;                                                     
    1430             m_cpt_ixr_cmd_fsm_trt_used      = 0 ;                                                 
    1431             m_cpt_ixr_rsp_fsm_trt_used      = 0 ;                                                     
    1432             m_cpt_cleanup_fsm_trt_used      = 0 ;                                             
    1433                                                                                                                  
    1434             m_cpt_trt_unused                = 0 ;                                                 
    1435                                                                                        
    1436             m_cpt_cleanup_fsm_ivt_lock      = 0 ;                                             
    1437             m_cpt_cleanup_fsm_n_ivt_lock    = 0 ;                                                         
    1438                                                                                          
    1439             m_cpt_multi_ack_fsm_ivt_lock    = 0 ;                                                 
    1440             m_cpt_multi_ack_fsm_n_ivt_lock  = 0 ;                                             
    1441                                                                                        
    1442             m_cpt_ivt_unused                = 0 ;                             
    1443                                                                                          
    1444             m_cpt_read_fsm_heap_lock        = 0 ;                                                     
    1445             m_cpt_write_fsm_heap_lock       = 0 ;                                                 
    1446             m_cpt_cas_fsm_heap_lock         = 0 ;                                             
    1447             m_cpt_cleanup_fsm_heap_lock     = 0 ;                                                         
    1448             m_cpt_xram_rsp_fsm_heap_lock    = 0 ;                                                             
    1449             m_cpt_multi_ack_fsm_heap_lock   = 0 ;                                                 
    1450                                                                                        
    1451             m_cpt_read_fsm_n_heap_lock      = 0 ;                                                 
    1452             m_cpt_write_fsm_n_heap_lock     = 0 ;                                             
    1453             m_cpt_cas_fsm_n_heap_lock       = 0 ;                                                     
    1454             m_cpt_cleanup_fsm_n_heap_lock   = 0 ;                                                     
    1455             m_cpt_xram_rsp_fsm_n_heap_lock  = 0 ;                                                         
    1456             m_cpt_multi_ack_fsm_n_heap_lock = 0 ;                                                         
    1457                                                                                                                      
    1458             m_cpt_read_fsm_heap_used        = 0 ;                                                 
    1459             m_cpt_write_fsm_heap_used       = 0 ;                                                 
    1460             m_cpt_cas_fsm_heap_used         = 0 ;                                             
    1461             m_cpt_cleanup_fsm_heap_used     = 0 ;                                         
    1462             m_cpt_xram_rsp_fsm_heap_used    = 0 ;                                         
    1463             m_cpt_multi_ack_fsm_heap_used   = 0 ;                                                     
    1464                                                                                          
    1465             m_cpt_heap_unused               = 0 ;                     
    1466             m_cpt_slot_inval                = 0 ;
     1187            m_cpt_reset_count               = 0;
     1188            m_cpt_read_local                = 0;
     1189            m_cpt_read_remote               = 0;
     1190            m_cpt_read_cost                 = 0;
     1191
     1192            m_cpt_write_local               = 0;
     1193            m_cpt_write_remote              = 0;
     1194            m_cpt_write_flits_local         = 0;
     1195            m_cpt_write_flits_remote        = 0;
     1196            m_cpt_write_cost                = 0;
     1197
     1198            m_cpt_ll_local                  = 0;
     1199            m_cpt_ll_remote                 = 0;
     1200            m_cpt_ll_cost                   = 0;
     1201
     1202            m_cpt_sc_local                  = 0;
     1203            m_cpt_sc_remote                 = 0;
     1204            m_cpt_sc_cost                   = 0;
     1205
     1206            m_cpt_cas_local                 = 0;
     1207            m_cpt_cas_remote                = 0;
     1208            m_cpt_cas_cost                  = 0;
     1209
     1210            m_cpt_minval                    = 0;
     1211            m_cpt_minval_local              = 0;
     1212            m_cpt_minval_remote             = 0;
     1213            m_cpt_minval_cost               = 0;
     1214
     1215            m_cpt_binval                    = 0;
     1216            m_cpt_write_broadcast           = 0;
     1217            m_cpt_getm_broadcast            = 0;
     1218
     1219            m_cpt_cleanup_local             = 0;
     1220            m_cpt_cleanup_remote            = 0;
     1221            m_cpt_cleanup_cost              = 0;
     1222            m_cpt_cleanup_data_local        = 0;
     1223            m_cpt_cleanup_data_remote       = 0;
     1224            m_cpt_cleanup_data_cost         = 0;
     1225
     1226            m_cpt_read_miss                 = 0;
     1227            m_cpt_write_miss                = 0;
     1228            m_cpt_write_dirty               = 0;
     1229            m_cpt_getm_miss                 = 0;
     1230
     1231            m_cpt_getm_local                = 0;
     1232            m_cpt_getm_remote               = 0;
     1233            m_cpt_getm_cost                 = 0;
     1234
     1235            m_cpt_inval_ro_local            = 0;
     1236            m_cpt_inval_ro_remote           = 0;
     1237            m_cpt_inval_ro_cost             = 0;
     1238
     1239            m_cpt_trt_rb                    = 0;
     1240            m_cpt_trt_full                  = 0;
     1241            m_cpt_put                       = 0;
     1242            m_cpt_get                       = 0;
     1243
     1244            m_cpt_heap_unused               = 0;
     1245            m_cpt_slot_inval                = 0;
     1246
    14671247            return;
    14681248        }
     
    15151295
    15161296#if DEBUG_MEMC_GLOBAL
    1517         if(m_debug)
     1297        if (m_debug)
    15181298        {
    15191299            std::cout
     
    15651345            //////////////////
    15661346            case TGT_CMD_IDLE:     // waiting a VCI command (RAM or CONFIG)
    1567                 if(p_vci_tgt.cmdval)
     1347                if (p_vci_tgt.cmdval)
    15681348                {
    15691349
    15701350#if DEBUG_MEMC_TGT_CMD
    1571                     if(m_debug)
     1351                    if (m_debug)
    15721352                        std::cout << "  <MEMC " << name()
    15731353                            << " TGT_CMD_IDLE> Receive command from srcid "
     
    15871367                        {
    15881368                            found = true;
    1589                             if ( m_seg[seg_id]->special() ) config = true;
     1369                            if (m_seg[seg_id]->special() ) config = true;
    15901370                        }
    15911371                    }
     
    15931373                    if (!found)                /////////// out of segment error
    15941374                    {
    1595                         r_tgt_cmd_fsm   = TGT_CMD_ERROR;
    1596                     }
    1597                     else if ( config )              /////////// configuration command
     1375                        r_tgt_cmd_fsm = TGT_CMD_ERROR;
     1376                    }
     1377                    else if (config )              /////////// configuration command
    15981378                    {
    15991379                        if (!p_vci_tgt.eop.read()) r_tgt_cmd_fsm = TGT_CMD_ERROR;
    1600                         else                            r_tgt_cmd_fsm = TGT_CMD_CONFIG;
     1380                        else                       r_tgt_cmd_fsm = TGT_CMD_CONFIG;
    16011381                    }
    16021382                    else                            //////////// memory access
    16031383                    {
    1604                         if ( p_vci_tgt.cmd.read() == vci_param_int::CMD_READ )
     1384                        if (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)
    16051385                        {
    16061386                            // check that the pktid is either :
     
    16151395                            r_tgt_cmd_fsm = TGT_CMD_READ;
    16161396                        }
    1617                         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
     1397                        else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
    16181398                        {
    16191399                          // check that the pktid is TYPE_WRITE
     
    16221402                            r_tgt_cmd_fsm = TGT_CMD_WRITE;
    16231403                        }
    1624                         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
     1404                        else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
    16251405                        {
    16261406                            // check that the pktid is TYPE_LL
     
    16311411                            r_tgt_cmd_fsm = TGT_CMD_READ;
    16321412                        }
    1633                         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP)
     1413                        else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP)
    16341414                        {
    16351415                            // check that the pktid is either :
     
    16421422                                    "The type specified in the pktid field is incompatible with the NOP CMD");
    16431423
    1644                             if((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
    1645                             else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE;
     1424                            if ((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
     1425                            else                                            r_tgt_cmd_fsm = TGT_CMD_WRITE;
    16461426                        }
    16471427                        else
     
    16571437
    16581438                // wait if pending request
    1659                 if(r_tgt_cmd_to_tgt_rsp_req.read()) break;
     1439                if (r_tgt_cmd_to_tgt_rsp_req.read()) break;
    16601440
    16611441                // consume all the command packet flits before sending response error
    1662                 if ( p_vci_tgt.cmdval and p_vci_tgt.eop )
     1442                if (p_vci_tgt.cmdval and p_vci_tgt.eop)
    16631443                {
    16641444                    r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
     
    16701450
    16711451#if DEBUG_MEMC_TGT_CMD
    1672                     if(m_debug)
     1452                    if (m_debug)
    16731453                        std::cout << "  <MEMC " << name()
    16741454                            << " TGT_CMD_ERROR> Segmentation violation:"
     
    18851665                    uint32_t wdata = p_vci_tgt.wdata.read();     
    18861666
    1887                     if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
     1667                    if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
    18881668                            and (cell == MEMC_LOCK) )
    18891669                    {
     
    18931673                        r_config_lock    = true;
    18941674                    }
    1895                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)  // release lock
     1675                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)  // release lock
    18961676                            and (cell == MEMC_LOCK))
    18971677                    {
     
    19001680                        r_config_lock    = false;
    19011681                    }
    1902                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_lo
     1682                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_lo
    19031683                            and (cell == MEMC_ADDR_LO))
    19041684                    {
     
    19111691                            ((addr_t)wdata);
    19121692                    }
    1913                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_hi
     1693                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_hi
    19141694                            and (cell == MEMC_ADDR_HI))
    19151695                    {
     
    19191699                            (((addr_t) wdata) << 32);
    19201700                    }
    1921                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
     1701                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
    19221702                            and (cell == MEMC_BUF_LENGTH))
    19231703                    {
     
    19291709                        r_config_rsp_lines  = 0;
    19301710                    }
    1931                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set cmd type
     1711                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set cmd type
    19321712                            and (cell == MEMC_CMD_TYPE))
    19331713                    {
     
    19451725                    }
    19461726
    1947                     if ( need_rsp )
     1727                    if (need_rsp )
    19481728                    {
    19491729                        // blocked if previous pending request to TGT_RSP FSM
    1950                         if ( r_tgt_cmd_to_tgt_rsp_req.read() ) break;
     1730                        if (r_tgt_cmd_to_tgt_rsp_req.read() ) break;
    19511731
    19521732                        r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
     
    19641744
    19651745#if DEBUG_MEMC_TGT_CMD
    1966                     if(m_debug)
     1746                    if (m_debug)
    19671747                        std::cout << "  <MEMC " << name() << " TGT_CMD_CONFIG> Configuration request:"
    19681748                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    19781758
    19791759                // check that the read does not cross a cache line limit.
    1980                 if ( ((m_x[(addr_t) p_vci_tgt.address.read()]+ (p_vci_tgt.plen.read() >>2)) > 16) and
     1760                if (((m_x[(addr_t) p_vci_tgt.address.read()]+ (p_vci_tgt.plen.read() >>2)) > 16) and
    19811761                        (p_vci_tgt.cmd.read() != vci_param_int::CMD_LOCKED_READ))
    19821762                {
     
    19861766                }
    19871767                // check single flit
    1988                 if(!p_vci_tgt.eop.read())
     1768                if (!p_vci_tgt.eop.read())
    19891769                {
    19901770                    std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
     
    19931773                }
    19941774                // check plen for LL
    1995                 if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
     1775                if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
    19961776                        (p_vci_tgt.plen.read() != 8) )
    19971777                {
     
    20011781                }
    20021782
    2003                 if ( p_vci_tgt.cmdval and m_cmd_read_addr_fifo.wok() )
     1783                if (p_vci_tgt.cmdval and m_cmd_read_addr_fifo.wok() )
    20041784                {
    20051785
    20061786#if DEBUG_MEMC_TGT_CMD
    2007                     if(m_debug)
     1787                    if (m_debug)
    20081788                        std::cout << "  <MEMC " << name() << " TGT_CMD_READ> Push into read_fifo:"
    20091789                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    20161796                    // <Activity counters>
    20171797                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) {
    2018                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_ll_local++;
    2019                         else                                      m_cpt_ll_remote++;
    2020                         m_cpt_ll_cost += req_distance(p_vci_tgt.srcid.read()); // LL on a single word
    2021                     }
    2022                     else {
    2023                         if ((p_vci_tgt.pktid.read() & 0x7) == TYPE_WRITE)
    2024                         {
    2025                             if ((p_vci_tgt.pktid.read() & 0x8) == 0x8)
    2026                             {
    2027                                 if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_getm_hit_local++;
    2028                                 else                                      m_cpt_getm_hit_remote++;
    2029                             }
    2030                             else
    2031                             {
    2032                                 if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_getm_miss_local++;
    2033                                 else                                      m_cpt_getm_miss_remote++;
    2034                             }
    2035                             m_cpt_getm_cost += req_distance(p_vci_tgt.srcid.read());
     1798                        if (is_local_req(p_vci_tgt.srcid.read()))
     1799                        {
     1800                            m_cpt_ll_local++;
    20361801                        }
    20371802                        else
    20381803                        {
    2039                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_read_miss_local++;
    2040                             else                                      m_cpt_read_miss_remote++;
    2041                             m_cpt_read_miss_cost += req_distance(p_vci_tgt.srcid.read());
    2042                         }
     1804                            m_cpt_ll_remote++;
     1805                        }
     1806                        // (1 (CMD) + 2 (RSP)) VCI flits for LL => 2 + 3 dspin flits
     1807                        m_cpt_ll_cost += 5 * req_distance(p_vci_tgt.srcid.read()); // LL on a single word
     1808                    }
     1809                    else if ((p_vci_tgt.pktid.read() & 0x7) == TYPE_WRITE)
     1810                    {
     1811                        if (is_local_req(p_vci_tgt.srcid.read()))
     1812                        {
     1813                            m_cpt_getm_local++;
     1814                        }
     1815                        else
     1816                        {
     1817                            m_cpt_getm_remote++;
     1818                        }
     1819                        // (1 (CMD) + m_words (RSP)) flits VCI => 2 + m_words + 1 flits dspin
     1820                        m_cpt_getm_cost += (3 + m_words) * req_distance(p_vci_tgt.srcid.read());
     1821                    }
     1822                    else
     1823                    {
     1824                        if (is_local_req(p_vci_tgt.srcid.read()))
     1825                        {
     1826                            m_cpt_read_local++;
     1827                        }
     1828                        else
     1829                        {
     1830                            m_cpt_read_remote++;
     1831                        }
     1832                        // (1 (CMD) + m_words (RSP)) flits VCI => 2 + m_words + 1 flits dspin
     1833                        m_cpt_read_cost += (3 + m_words) * req_distance(p_vci_tgt.srcid.read());
    20431834                    }
    20441835                    // </Activity counters>
     
    20491840                ///////////////////
    20501841            case TGT_CMD_WRITE:
    2051                 if(p_vci_tgt.cmdval and m_cmd_write_addr_fifo.wok())
    2052                 {
    2053 
     1842                if (p_vci_tgt.cmdval and m_cmd_write_addr_fifo.wok())
     1843                {
     1844                    uint32_t plen = p_vci_tgt.plen.read();
    20541845#if DEBUG_MEMC_TGT_CMD
    2055                     if(m_debug)
     1846                    if (m_debug)
    20561847                        std::cout << "  <MEMC " << name() << " TGT_CMD_WRITE> Push into write_fifo:"
    20571848                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    20611852                            << " / wdata = " << p_vci_tgt.wdata.read()
    20621853                            << " / be = " << p_vci_tgt.be.read()
    2063                             << " / plen = " << std::dec << p_vci_tgt.plen.read() << std::endl;
     1854                            << " / plen = " << std::dec << plen << std::endl;
    20641855#endif
    20651856                    cmd_write_fifo_put = true;
    20661857                    // <Activity counters>
    20671858                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
    2068                         m_cpt_sc_cost += req_distance(p_vci_tgt.srcid.read());
     1859                        // (2 (CMD) + 1 (RSP)) flits VCI => 4 + (1 (success) || 2 (failure)) flits dspin
     1860                        m_cpt_sc_cost += 5 * req_distance(p_vci_tgt.srcid.read());
    20691861                    }
    20701862                    else {
    2071                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_flits_local++;
    2072                         else                                      m_cpt_write_flits_remote++;
    2073                         m_cpt_write_cost += req_distance(p_vci_tgt.srcid.read());
     1863                        if (is_local_req(p_vci_tgt.srcid.read()))
     1864                        {
     1865                            m_cpt_write_flits_local++;
     1866                        }
     1867                        else
     1868                        {
     1869                            m_cpt_write_flits_remote++;
     1870                        }
     1871                        // (burst_size (CMD) + 1 (RSP) flits VCI => 2 + burst_size + 1 flits dspin
     1872                        m_cpt_write_cost += (3 + (plen >> 2)) * req_distance(p_vci_tgt.srcid.read());
    20741873                    }
    20751874                    // </Activity counters>
     
    20781877                        // <Activity counters>
    20791878                        if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
    2080                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_sc_local++;
    2081                             else                                      m_cpt_sc_remote++;
    2082 
     1879                            if (is_local_req(p_vci_tgt.srcid.read()))
     1880                            {
     1881                                m_cpt_sc_local++;
     1882                            }
     1883                            else
     1884                            {
     1885                                m_cpt_sc_remote++;
     1886                            }
    20831887                        }
    20841888                        else {
    2085                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_local++;
    2086                             else                                      m_cpt_write_remote++;
     1889                            if (is_local_req(p_vci_tgt.srcid.read()))
     1890                            {
     1891                                m_cpt_write_local++;
     1892                            }
     1893                            else
     1894                            {
     1895                                m_cpt_write_remote++;
     1896                            }
    20871897                        }
    20881898                        // </Activity counters>
     
    20931903                /////////////////
    20941904            case TGT_CMD_CAS:
    2095                 if((p_vci_tgt.plen.read() != 8) and (p_vci_tgt.plen.read() != 16))
     1905                if ((p_vci_tgt.plen.read() != 8) and (p_vci_tgt.plen.read() != 16))
    20961906                {
    20971907                    std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_CAS state"
     
    21001910                }
    21011911
    2102                 if(p_vci_tgt.cmdval and m_cmd_cas_addr_fifo.wok())
     1912                if (p_vci_tgt.cmdval and m_cmd_cas_addr_fifo.wok())
    21031913                {
    21041914
    21051915#if DEBUG_MEMC_TGT_CMD
    2106                     if(m_debug)
     1916                    if (m_debug)
    21071917                        std::cout << "  <MEMC " << name() << " TGT_CMD_CAS> Pushing command into cmd_cas_fifo:"
    21081918                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    21171927                    if (p_vci_tgt.eop) {
    21181928                        // <Activity counters>
    2119                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_cas_local++;
    2120                         else                                      m_cpt_cas_remote++;
    2121                         m_cpt_cas_cost += req_distance(p_vci_tgt.srcid.read());
     1929                        if (is_local_req(p_vci_tgt.srcid.read()))
     1930                        {
     1931                            m_cpt_cas_local++;
     1932                        }
     1933                        else
     1934                        {
     1935                            m_cpt_cas_remote++;
     1936                        }
     1937                        // (2 (CMD) + 1 (RSP)) flits VCI => 4 + (1 (success) || 2 (failure)) flits dspin
     1938                        m_cpt_cas_cost += 5 * req_distance(p_vci_tgt.srcid.read());
    21221939                        // </Activity counters>
    21231940                        r_tgt_cmd_fsm = TGT_CMD_IDLE;
     
    21511968                    uint64_t flit = m_cc_receive_to_multi_ack_fifo.read();
    21521969
    2153                     if( not multi_ack_fifo_rok )
     1970                    if (not multi_ack_fifo_rok)
    21541971                        break;
    21551972
    2156                     size_t ivt_index    = DspinDhccpParam::dspin_get(flit,
    2157                                     DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
    2158 
    2159                     bool miss_updt    = DspinDhccpParam::dspin_get(flit,
    2160                                     DspinDhccpParam::MULTI_ACK_UPDT_MISS);
    2161 
    2162                     bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     1973                    size_t ivt_index = DspinHmesiParam::dspin_get(flit,
     1974                                    DspinHmesiParam::MULTI_ACK_UPDT_INDEX);
     1975
     1976                    bool miss_updt = DspinHmesiParam::dspin_get(flit,
     1977                                    DspinHmesiParam::MULTI_ACK_UPDT_MISS);
     1978
     1979                    bool eop = DspinHmesiParam::dspin_get(flit, DspinHmesiParam::P2M_EOP) == 0x1;
    21631980
    21641981                    cc_receive_to_multi_ack_fifo_get = true;
     
    21711988                    r_multi_ack_miss_updt = miss_updt;
    21721989
    2173                     if(miss_updt)
    2174                         m_cpt_multi_ack_miss ++;
    2175                     else
    2176                         m_cpt_multi_ack_hit ++;
    2177 
    2178                     if( not eop)
    2179                     {
    2180                         r_multi_ack_fsm = MULTI_ACK_GET_DATA;
     1990                    if (not eop)
     1991                    {
    21811992                        r_multi_ack_need_data = true;
    21821993                        r_multi_ack_data_index = 0;
    2183                         m_cpt_multi_ack_hit_with_data ++;
     1994                        r_multi_ack_fsm = MULTI_ACK_GET_DATA;
    21841995                    }
    21851996                    else
    21861997                    {
     1998                        r_multi_ack_need_data = false;
    21871999                        r_multi_ack_fsm = MULTI_ACK_DIR_REQ;
    2188                         r_multi_ack_need_data = false;
    21892000                    }
    21902001
    21912002#if DEBUG_MEMC_MULTI_ACK
    2192                     if(m_debug)
     2003                    if (m_debug)
    21932004                    {
    21942005                        if (multi_ack_fifo_rok)
     
    22112022
    22122023                        uint32_t data =
    2213                             DspinDhccpParam::dspin_get (flit, DspinDhccpParam::CLEANUP_DATA_UPDT);
    2214 
    2215                         bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     2024                            DspinHmesiParam::dspin_get (flit, DspinHmesiParam::CLEANUP_DATA_UPDT);
     2025
     2026                        bool eop = DspinHmesiParam::dspin_get(flit, DspinHmesiParam::P2M_EOP) == 0x1;
    22162027#if DEBUG_MEMC_CLEANUP
    2217                         if(m_debug)
     2028                        if (m_debug)
    22182029                        {
    22192030                            std::cout
     
    22422053            case MULTI_ACK_IVT_LOCK:
    22432054                {
    2244                     m_cpt_multi_ack_fsm_ivt_lock ++;
    2245                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK)  break;
    2246 
    2247                     m_cpt_multi_ack_fsm_n_ivt_lock ++;
     2055                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK)  break;
    22482056
    22492057                    assert( r_alloc_dir_fsm.read() == ALLOC_DIR_MULTI_ACK && " BAD ALLOC_DIR_MULTI_ACK IN MULTI_ACK_IVT_LOCK STATE");
    2250                     size_t index  = r_multi_ack_ivt_index.read();
    2251                     size_t count  = m_ivt.count(index);
    2252                     size_t nline  = m_ivt.nline(index);
     2058                    size_t index = r_multi_ack_ivt_index.read();
     2059                    size_t count = m_ivt.count(index);
     2060                    size_t nline = m_ivt.nline(index);
    22532061                    r_multi_ack_nline = nline;
    22542062                    r_multi_ack_srcid = m_ivt.srcid(index);
     
    22562064                    r_multi_ack_pktid = m_ivt.pktid(index);
    22572065                    r_multi_ack_rsp   = m_ivt.need_rsp(index);
    2258                     //bool is_valid = m_ivt.is_valid(index);
    2259 
    2260                     // if(r_multi_ack_miss_updt.read())
    2261                     //{
    2262                         r_multi_ack_fsm = MULTI_ACK_DIR_LOCK; // this way may be bring about the problem of critical path
    2263                     //}                   
    2264                     //else
    2265                     //{
    2266                         bool is_updt  = m_ivt.is_update(index);
     2066                    uint32_t srcid = m_ivt.srcid(index);
    22672067                   
    2268                         assert(is_updt && "MULTI_ACK: is not an updt index for a multi ack rsp");
    2269                         assert(count == 1 && "there is only one copy in the memc");
    2270 
    2271                     //  r_multi_ack_fsm = MULTI_ACK_IVT_CLEAR;
     2068                    // <Activity Counters>
     2069                    // We count "read-only invalidations" at the same place as
     2070                    // multi ack.
     2071                    // The idea is that a RO inval is always responded by a multi ack,
     2072                    // and that a multi ack is sent only for inval RO.
     2073                    // Thus, we add one to the cost for the inval RO fleet, and
     2074                    // depending on the response, we add either 1 or m_words + 1 for the cost for the multi ack flits
     2075                    if (r_multi_ack_need_data.read())
     2076                    {
     2077                        // multi_ack with data
     2078                        if (is_local_req(srcid))
     2079                        {
     2080                            m_cpt_inval_ro_local++;
     2081                        }
     2082                        else
     2083                        {
     2084                            m_cpt_inval_ro_remote++;
     2085                        }
     2086                        // 2 flits for inval RO + (m_words + 1) flits for the multi ack
     2087                        m_cpt_inval_ro_cost += (m_words + 1) * req_distance(srcid);
     2088                    }
     2089                    else
     2090                    {
     2091                        // multi_ack without data
     2092                        if (is_local_req(srcid))
     2093                        {
     2094                            m_cpt_inval_ro_local++;
     2095                        }
     2096                        else
     2097                        {
     2098                            m_cpt_inval_ro_remote++;
     2099                        }
     2100                        // 2 flits for inval RO + 1 flit for the multi ack
     2101                        m_cpt_inval_ro_cost += 3 * req_distance(srcid); // 1 flit
     2102                    }
     2103                    // </Activity Counters>
     2104
     2105
     2106                    r_multi_ack_fsm = MULTI_ACK_DIR_LOCK; // this way may be bring about the problem of critical path
     2107                    bool is_updt  = m_ivt.is_update(index);
     2108                   
     2109                    assert(is_updt && "MULTI_ACK: is not an updt index for a multi ack rsp");
     2110                    assert(count == 1 && "there is only one copy in the memc");
    22722111
    22732112#if DEBUG_MEMC_MULTI_ACK
    2274                     if(m_debug)
     2113                    if (m_debug)
    22752114                        std::cout << "  <MEMC " << name()
    22762115                            << " MULTI_ACK_IVT_LOCK> "
     
    22832122            case MULTI_ACK_IVT_CLEAR:
    22842123                {
    2285                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK )
     2124                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK )
    22862125                    {
    22872126                        std::cout
     
    22972136           
    22982137#if DEBUG_MEMC_MULTI_ACK
    2299                     if(m_debug)
     2138                    if (m_debug)
    23002139                        std::cout << "  <MEMC " << name()
    23012140                            << " MULTI_ACK_IVT_CLEAR> IVT clear:"
     
    23082147            case MULTI_ACK_DIR_REQ:   // Get the lock to the directory
    23092148                {
    2310                     m_cpt_multi_ack_fsm_dir_lock ++;
    2311                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK) break;
     2149                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK) break;
    23122150
    23132151                    r_multi_ack_fsm = MULTI_ACK_IVT_LOCK;
    23142152                    //std::cout << " MEM_CACHE : CLEANUP_DIR_REQ" << std::endl;
    2315                     m_cpt_multi_ack_fsm_n_dir_lock ++;
    23162153
    23172154#if DEBUG_MEMC_CLEANUP
    2318                     if(m_debug)
     2155                    if (m_debug)
    23192156                        std::cout << "  <MEMC " << name() << " MULTI_ACK_DIR_REQ> Requesting DIR lock" << std::endl;
    23202157#endif
     
    23252162            case MULTI_ACK_DIR_LOCK: //updt data with the registers which have saved the set and way
    23262163                {
    2327                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
     2164                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
    23282165                    {
    23292166                        std::cout
     
    23492186
    23502187#if DEBUG_MEMC_MULTI_ACK
    2351                     if(m_debug)
     2188                    if (m_debug)
    23522189                    {
    23532190                        std::cout
     
    23652202                    }
    23662203#endif
    2367                     assert( (entry.state == ENTRY_LOCKED) && "mutli rsp check the entry, the line is not locked!!!");
     2204                    assert((entry.state == ENTRY_LOCKED) && "multi rsp check the entry, the line is not locked!!!");
    23682205                       
    2369                     if(r_multi_ack_miss_updt.read() and entry.count) //cache L1 has sent the cleanup when it receives the cc_updt request,
     2206                    if (r_multi_ack_miss_updt.read() and entry.count) //cache L1 has sent the cleanup when it receives the cc_updt request,
    23702207                    {
    23712208                        r_multi_ack_fsm = MULTI_ACK_IVT_CHANGE;
    23722209                    }
    2373                     else if( not entry.count or match_ll) // The line has been already evicted from cache L1
     2210                    else if (not entry.count or match_ll) // The line has been already evicted from cache L1
    23742211                    {
    23752212                        assert(((entry.count == 1) or (entry.count == 0)) && "multi ack for a ll request, count is 1");
    2376                         r_multi_ack_fsm        = MULTI_ACK_DIR_UPDT;
     2213                        r_multi_ack_fsm = MULTI_ACK_DIR_UPDT;
    23772214                    }
    23782215                    else
    23792216                    {
    2380                         r_multi_ack_fsm        = MULTI_ACK_HEAP_REQ;
     2217                        r_multi_ack_fsm = MULTI_ACK_HEAP_REQ;
    23812218                    }
    23822219                    break;
    23832220                }
    23842221                /////////////
    2385             case MULTI_ACK_IVT_CHANGE:   // release all locks and retry from beginning
     2222            case MULTI_ACK_IVT_CHANGE:
    23862223                {                 
    2387                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK )
     2224                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK)
    23882225                    {
    23892226                        std::cout
     
    23962233                    m_ivt.change(r_multi_ack_ivt_index.read());
    23972234#if DEBUG_MEMC_MULTI_ACK
    2398                     if(m_debug)
     2235                    if (m_debug)
    23992236                    {
    24002237                        std::cout << "  <MEMC " << name()
     
    24082245            case MULTI_ACK_DIR_UPDT:
    24092246                {
    2410                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
     2247                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
    24112248                    {
    24122249                        std::cout
     
    24202257                    bool match_ll = ((r_multi_ack_pktid.read() & 0x07) == TYPE_LL);
    24212258
    2422                     if(r_multi_ack_need_data.read())
    2423                     {
    2424                         for(size_t word=0; word<m_words ; word++)
     2259                    if (r_multi_ack_need_data.read())
     2260                    {
     2261                        for (size_t word = 0; word<m_words; word++)
    24252262                        {
    24262263                            m_cache_data.write(r_multi_ack_way.read(),
     
    24292266                                               r_multi_ack_data[word]);
    24302267                        }
    2431                        // addr_t min = r_multi_ack_nline.read()*m_words*4 ;
    2432                        // addr_t max = r_multi_ack_nline.read()*m_words*4 + (m_words - 1)*4;
    2433                        // m_llsc_table.sw(min, max);
    2434  
    24352268                    }
    24362269                    else
    24372270                    {
    2438                         m_cache_data.read_line( r_multi_ack_way.read(),
    2439                                                 r_multi_ack_set.read(),
    2440                                                 r_multi_ack_data);
     2271                        m_cache_data.read_line(r_multi_ack_way.read(),
     2272                                               r_multi_ack_set.read(),
     2273                                               r_multi_ack_data);
    24412274                    }
    24422275
    24432276                    DirectoryEntry entry;
    2444                     entry.is_cnt         = false;
    2445                     entry.dirty          = r_multi_ack_dirty.read() or r_multi_ack_need_data.read();
    2446                     entry.tag            = r_multi_ack_tag.read();
    2447                     entry.lock           = r_multi_ack_lock.read();
    2448                     entry.ptr            = 0;
    2449 
    2450                     if(match_ll)
    2451                     {
    2452                         entry.owner.srcid    = r_multi_ack_copy.read();
    2453                         entry.count          = r_multi_ack_count.read();
     2277                    entry.is_cnt = false;
     2278                    entry.dirty  = r_multi_ack_dirty.read() or r_multi_ack_need_data.read();
     2279                    entry.tag    = r_multi_ack_tag.read();
     2280                    entry.lock   = r_multi_ack_lock.read();
     2281                    entry.ptr    = 0;
     2282
     2283                    if (match_ll)
     2284                    {
     2285                        entry.owner.srcid = r_multi_ack_copy.read();
     2286                        entry.count       = r_multi_ack_count.read();
    24542287                    }
    24552288                    else
    24562289                    {
    2457                         entry.owner.srcid    = r_multi_ack_srcid.read();
    2458                         entry.count          = 1;
    2459                     }
    2460 
    2461 
    2462                    // if( (r_multi_ack_pktid.read() & 0x07) == 0x03 or match_ll)
    2463                    // {
    2464                         entry.state          = ENTRY_SHARED; // MISS INST
    2465                    // }
    2466                    //  else
    2467                    //  {
    2468                    //     entry.state          = ENTRY_EXCLUSIVE; // MISS DATA
    2469                    // }
    2470 
    2471                     if((r_multi_ack_pktid.read() & 0x7) == 0x03)
     2290                        entry.owner.srcid = r_multi_ack_srcid.read();
     2291                        entry.count       = 1;
     2292                    }
     2293
     2294                    entry.state = ENTRY_SHARED; // MISS INST
     2295
     2296                    if ((r_multi_ack_pktid.read() & 0x7) == 0x03)
    24722297                    {
    24732298                        entry.owner.inst = true;
     
    24832308                    r_multi_ack_fsm      = MULTI_ACK_IVT_CLEAR;
    24842309#if DEBUG_MEMC_MULTI_ACK
    2485                     if(m_debug)
     2310                    if (m_debug)
    24862311                    {
    24872312                        std::cout << "  <MEMC " << name() << " MULTI_ACK_DIR_UPDT>"
     
    24992324                // wait if pending request to the TGT_RSP FSM
    25002325                {
    2501                     if(r_multi_ack_to_tgt_rsp_req.read()) break;
    2502 
    2503                     for(size_t i = 0; i<m_words; i++)
     2326                    if (r_multi_ack_to_tgt_rsp_req.read()) break;
     2327
     2328                    for (size_t i = 0; i<m_words; i++)
    25042329                    {
    25052330                        r_multi_ack_to_tgt_rsp_data[i] = r_multi_ack_data[i].read();
    25062331                    }
    25072332                    // no pending request
    2508                     r_multi_ack_to_tgt_rsp_req     = true;
    2509                     if( r_read_to_multi_ack_req.read() and (r_read_to_multi_ack_nline.read() == r_multi_ack_nline.read()))
    2510                     {
    2511                         r_multi_ack_to_tgt_rsp_word    = r_read_to_multi_ack_first_word.read();
    2512                         r_multi_ack_to_tgt_rsp_length  = r_read_to_multi_ack_length.read();
    2513                         r_read_to_multi_ack_req        = false;
     2333                    r_multi_ack_to_tgt_rsp_req = true;
     2334                    if (r_read_to_multi_ack_req.read() and (r_read_to_multi_ack_nline.read() == r_multi_ack_nline.read()))
     2335                    {
     2336                        r_multi_ack_to_tgt_rsp_word   = r_read_to_multi_ack_first_word.read();
     2337                        r_multi_ack_to_tgt_rsp_length = r_read_to_multi_ack_length.read();
     2338                        r_read_to_multi_ack_req       = false;
    25142339                    }
    25152340                    else
    25162341                    {
    2517                         r_multi_ack_to_tgt_rsp_word    = 0;
    2518                         r_multi_ack_to_tgt_rsp_length  = 16;
    2519                     }
    2520 
    2521                     r_multi_ack_to_tgt_ll_key      = r_read_to_multi_ack_ll_key.read();
    2522                     r_multi_ack_to_tgt_rsp_srcid   = r_multi_ack_srcid.read();
    2523                     r_multi_ack_to_tgt_rsp_trdid   = r_multi_ack_trdid.read();
    2524 
    2525                    // if(r_multi_ack_rsp_shared.read()) // rsp read with shared or exclusive state
    2526                    // {
    2527                         r_multi_ack_to_tgt_rsp_pktid = r_multi_ack_pktid.read();
    2528                    // }
    2529                    // else
    2530                    //{
    2531                    //    r_multi_ack_to_tgt_rsp_pktid = 0x08 + r_multi_ack_pktid.read(); 
    2532                    //}
    2533 
    2534                    r_multi_ack_fsm = MULTI_ACK_IDLE;
     2342                        r_multi_ack_to_tgt_rsp_word   = 0;
     2343                        r_multi_ack_to_tgt_rsp_length = 16;
     2344                    }
     2345
     2346                    r_multi_ack_to_tgt_ll_key    = r_read_to_multi_ack_ll_key.read();
     2347                    r_multi_ack_to_tgt_rsp_srcid = r_multi_ack_srcid.read();
     2348                    r_multi_ack_to_tgt_rsp_trdid = r_multi_ack_trdid.read();
     2349                    r_multi_ack_to_tgt_rsp_pktid = r_multi_ack_pktid.read();
     2350
     2351                    r_multi_ack_fsm = MULTI_ACK_IDLE;
    25352352
    25362353#if DEBUG_MEMC_MULTI_ACK
    2537                     if(m_debug)
     2354                    if (m_debug)
    25382355                        std::cout << "  <MEMC " << name() << " MULTI_ACK_RSP>"
    25392356                            << " Send a response to a previous read/ll request: "
     
    25532370            case MULTI_ACK_HEAP_REQ:    // Get the lock to the HEAP directory
    25542371                {
    2555                     m_cpt_multi_ack_fsm_n_heap_lock ++;
    2556                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK)
     2372                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK)
    25572373                    {
    25582374                        r_multi_ack_fsm = MULTI_ACK_HEAP_LOCK;
    25592375                    }
    25602376
    2561                     m_cpt_multi_ack_fsm_heap_lock ++;
    25622377#if DEBUG_MEMC_MULTI_ACK
    2563                     if(m_debug)
     2378                    if (m_debug)
    25642379                        std::cout << "  <MEMC " << name() << " MULTI_ACK_HEAP_REQ>"
    25652380                            << " Requesting HEAP lock " << std::endl;
     
    25712386                // and prepare the HEAP update
    25722387                {
    2573                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
     2388                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
    25742389                       r_alloc_dir_fsm.read() == ALLOC_DIR_MULTI_ACK)
    25752390                    {
    2576                         if(r_multi_ack_need_data.read())
    2577                         {
    2578                             for(size_t word=0; word<m_words ; word++)
     2391                        if (r_multi_ack_need_data.read())
     2392                        {
     2393                            for (size_t word = 0; word < m_words ; word++)
    25792394                            {
    25802395                                m_cache_data.write(r_multi_ack_way.read(),
     
    25832398                                                   r_multi_ack_data[word]);
    25842399                            }
    2585 
    2586                            // addr_t min = r_multi_ack_nline.read()*m_words*4 ;
    2587                            // addr_t max = r_multi_ack_nline.read()*m_words*4 + (m_words - 1)*4;
    2588                            // m_llsc_table.sw(min, max);
    2589  
    25902400                        }
    25912401                        else
    25922402                        {
    2593                             m_cache_data.read_line( r_multi_ack_way.read(),
    2594                                                     r_multi_ack_set.read(),
    2595                                                     r_multi_ack_data);
     2403                            m_cache_data.read_line(r_multi_ack_way.read(),
     2404                                                   r_multi_ack_set.read(),
     2405                                                   r_multi_ack_data);
    25962406                        }
    25972407
     
    26062416                        entry.dirty  = r_multi_ack_dirty.read() or r_multi_ack_need_data.read();
    26072417                        entry.tag    = r_multi_ack_tag.read();
    2608                         if(not go_cnt)         // Not entering counter mode
    2609                         {
    2610                             entry.owner.srcid      = r_multi_ack_copy.read();
    2611                             entry.owner.inst       = r_multi_ack_copy_inst.read();
    2612                             entry.ptr              = m_heap.next_free_ptr();   // set pointer on the heap
    2613 
    2614                             HeapEntry heap_entry   = m_heap.next_free_entry();
    2615 
    2616                             r_multi_ack_next_ptr   = heap_entry.next;
    2617                             r_multi_ack_last_free  = (heap_entry.next == m_heap.next_free_ptr());
    2618                             r_multi_ack_fsm        = MULTI_ACK_HEAP_WRITE; // add an entry in the HEAP
     2418                        if (not go_cnt)         // Not entering counter mode
     2419                        {
     2420                            entry.owner.srcid = r_multi_ack_copy.read();
     2421                            entry.owner.inst  = r_multi_ack_copy_inst.read();
     2422                            entry.ptr         = m_heap.next_free_ptr();   // set pointer on the heap
     2423
     2424                            HeapEntry heap_entry = m_heap.next_free_entry();
     2425
     2426                            r_multi_ack_next_ptr  = heap_entry.next;
     2427                            r_multi_ack_last_free = (heap_entry.next == m_heap.next_free_ptr());
     2428                            r_multi_ack_fsm       = MULTI_ACK_HEAP_WRITE; // add an entry in the HEAP
    26192429                        }
    26202430                        else                // Entering Counter mode
     
    26292439
    26302440#if DEBUG_MEMC_MULTI_ACK
    2631                         if(m_debug)
     2441                        if (m_debug)
    26322442                            std::cout << "  <MEMC " << name() << " MULTI_ACK_HEAP_LOCK> Update directory:"
    26332443                                << " tag = " << std::hex << entry.tag
     
    26502460            case MULTI_ACK_HEAP_WRITE:       // add an entry in the heap
    26512461                {
    2652                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
     2462                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
    26532463                       r_alloc_dir_fsm.read() == ALLOC_DIR_MULTI_ACK)
    26542464                    {
    26552465                        HeapEntry heap_entry;
    2656                         heap_entry.owner.srcid    = r_multi_ack_srcid.read();
    2657 
    2658                         if( (r_multi_ack_pktid.read() & 0x07) == 0x03)
    2659                         {
    2660                             heap_entry.owner.inst     = 1;
     2466                        heap_entry.owner.srcid = r_multi_ack_srcid.read();
     2467
     2468                        if ((r_multi_ack_pktid.read() & 0x07) == 0x03)
     2469                        {
     2470                            heap_entry.owner.inst = 1;
    26612471                        }
    26622472                        else
    26632473                        {
    2664                             heap_entry.owner.inst     = 0;
    2665                         }
    2666 
    2667                         heap_entry.next           = m_heap.next_free_ptr();
     2474                            heap_entry.owner.inst = 0;
     2475                        }
     2476
     2477                        heap_entry.next = m_heap.next_free_ptr();
    26682478                        m_heap.write_free_entry(heap_entry);
    26692479                        m_heap.write_free_ptr(r_multi_ack_next_ptr.read());
    2670                         if(r_multi_ack_last_free.read())  m_heap.set_full();
     2480                        if (r_multi_ack_last_free.read())  m_heap.set_full();
    26712481
    26722482                        r_multi_ack_fsm = MULTI_ACK_IVT_CLEAR;
    26732483
    26742484#if DEBUG_MEMC_MULTI_ACK
    2675                         if(m_debug)
     2485                        if (m_debug)
    26762486                            std::cout << "  <MEMC " << name() << " MULTI_ACK_HEAP_WRITE> Add an entry in the heap:"
    26772487                                << " owner_id = " << std::hex << heap_entry.owner.srcid
     
    27542564        ////////////////////////////////////////////////////////////////////////////////////
    27552565
    2756         switch( r_config_fsm.read() )
     2566        switch (r_config_fsm.read())
    27572567        {
    27582568            /////////////////
    27592569            case CONFIG_IDLE:  // waiting a config request
    27602570                {
    2761                     if ( r_config_cmd.read() != MEMC_CMD_NOP
    2762                     {
    2763                         r_config_fsm    = CONFIG_LOOP;
     2571                    if (r_config_cmd.read() != MEMC_CMD_NOP
     2572                    {
     2573                        r_config_fsm = CONFIG_LOOP;
    27642574
    27652575#if DEBUG_MEMC_CONFIG
    2766                         if(m_debug)
     2576                        if (m_debug)
    27672577                            std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received"
    27682578                                << " address = " << std::hex << r_config_address.read()
     
    27762586            case CONFIG_LOOP:   // test last line to be handled
    27772587                {
    2778                     if ( r_config_cmd_lines.read() == 0 )
     2588                    if (r_config_cmd_lines.read() == 0)
    27792589                    {
    27802590                        r_config_cmd = MEMC_CMD_NOP;
     
    27872597
    27882598#if DEBUG_MEMC_CONFIG
    2789                     if(m_debug)
     2599                    if (m_debug)
    27902600                        std::cout << "  <MEMC " << name() << " CONFIG_LOOP>"
    27912601                            << " address = " << std::hex << r_config_address.read()   
     
    27982608            case CONFIG_WAIT:   // wait completion (last response)
    27992609                {
    2800                     if ( r_config_rsp_lines.read() == 0 )  // last response received
     2610                    if (r_config_rsp_lines.read() == 0)  // last response received
    28012611                    {
    28022612                        r_config_fsm = CONFIG_RSP;
     
    28042614
    28052615#if DEBUG_MEMC_CONFIG
    2806                     if(m_debug)
     2616                    if (m_debug)
    28072617                        std::cout << "  <MEMC " << name() << " CONFIG_WAIT>"
    28082618                            << " / lines to do = " << std::dec << r_config_rsp_lines.read() << std::endl;
     
    28132623            case CONFIG_RSP:  // request TGT_RSP FSM to return response
    28142624                {
    2815                     if ( not r_config_to_tgt_rsp_req.read() )
    2816                     {
    2817                         r_config_to_tgt_rsp_srcid  = r_config_srcid.read();
    2818                         r_config_to_tgt_rsp_trdid  = r_config_trdid.read();
    2819                         r_config_to_tgt_rsp_pktid  = r_config_pktid.read();
    2820                         r_config_to_tgt_rsp_error  = false;
    2821                         r_config_to_tgt_rsp_req    = true;
    2822                         r_config_fsm               = CONFIG_IDLE;
     2625                    if (not r_config_to_tgt_rsp_req.read() )
     2626                    {
     2627                        r_config_to_tgt_rsp_srcid = r_config_srcid.read();
     2628                        r_config_to_tgt_rsp_trdid = r_config_trdid.read();
     2629                        r_config_to_tgt_rsp_pktid = r_config_pktid.read();
     2630                        r_config_to_tgt_rsp_error = false;
     2631                        r_config_to_tgt_rsp_req   = true;
     2632                        r_config_fsm              = CONFIG_IDLE;
    28232633
    28242634#if DEBUG_MEMC_CONFIG
    2825                         if(m_debug)
     2635                        if (m_debug)
    28262636                            std::cout << "  <MEMC " << name() << " CONFIG_RSP> Request TGT_RSP FSM to return response:"
    28272637                                << " error = " << r_config_to_tgt_rsp_error.read()
     
    28382648            case CONFIG_DIR_REQ:  // Request directory lock
    28392649                {
    2840                     if ( r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG )
     2650                    if (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG )
    28412651                    {
    28422652                        r_config_fsm = CONFIG_DIR_ACCESS;
     
    28442654
    28452655#if DEBUG_MEMC_CONFIG
    2846                     if(m_debug)
     2656                    if (m_debug)
    28472657                        std::cout << "  <MEMC " << name() << " CONFIG_DIR_REQ>"
    28482658                            << " Request DIR access" << std::endl;
     
    28712681                            (r_config_cmd.read() == MEMC_CMD_INVAL))
    28722682                    {
    2873                         r_config_fsm    = CONFIG_IVT_LOCK;
    2874                     }
    2875                     else if ( (entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE) and                       // hit & sync command
     2683                        r_config_fsm = CONFIG_IVT_LOCK;
     2684                    }
     2685                    else if ((entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE) and                       // hit & sync command
    28762686                            entry.dirty and (r_config_cmd.read() == MEMC_CMD_SYNC) )
    28772687                    {
    28782688                        r_config_fsm = CONFIG_TRT_LOCK;
    28792689                    }
    2880                     else if( entry.state == ENTRY_LOCKED)
     2690                    else if (entry.state == ENTRY_LOCKED)
    28812691                    {   // wait for unlock
    28822692                        r_config_fsm = CONFIG_WAIT;
     
    28912701
    28922702#if DEBUG_MEMC_CONFIG
    2893                     if(m_debug)
     2703                    if (m_debug)
    28942704                        std::cout << "  <MEMC " << name() << " CONFIG_DIR_ACCESS> Accessing directory: "
    28952705                            << " address = " << std::hex << r_config_address.read()
     
    29122722                            "MEMC ERROR in CONFIG_TRT_LOCK state: bad DIR allocation");
    29132723
    2914                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG )
     2724                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG)
    29152725                    {
    29162726                        size_t index = 0;
    2917                         bool   wok  = not m_trt.full(index);
    2918 
    2919                         if ( not wok )
     2727                        bool wok = not m_trt.full(index);
     2728
     2729                        if (not wok)
    29202730                        {
    29212731                            r_config_fsm = CONFIG_LOOP;
     
    29232733                        else
    29242734                        {
    2925                             size_t          way = r_config_dir_way.read();
    2926                             size_t          set = m_y[r_config_address.read()];
     2735                            size_t way = r_config_dir_way.read();
     2736                            size_t set = m_y[r_config_address.read()];
    29272737
    29282738                            // reset dirty bit in DIR
     
    29402750
    29412751                            r_config_trt_index = index;
    2942                             r_config_fsm       = CONFIG_TRT_SET;
     2752                            r_config_fsm = CONFIG_TRT_SET;
    29432753                        }
    29442754
    29452755#if DEBUG_MEMC_CONFIG
    2946                         if(m_debug)
     2756                        if (m_debug)
    29472757                            std::cout << "  <MEMC " << name() << " CONFIG_TRT_LOCK> Access TRT: "
    29482758                                << " wok = " << std::dec << wok
     
    29562766                // and post a PUT request in TRT
    29572767                {
    2958                     assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
     2768                    assert((r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
    29592769                            "MEMC ERROR in CONFIG_TRT_SET state: bad DIR allocation");
    29602770
    2961                     assert( (r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG) and
     2771                    assert((r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG) and
    29622772                            "MEMC ERROR in CONFIG_TRT_SET state: bad TRT allocation");
    29632773
    29642774                    // read data into cache
    2965                     size_t          way = r_config_dir_way.read();
    2966                     size_t          set = m_y[r_config_address.read()];
     2775                    size_t way = r_config_dir_way.read();
     2776                    size_t set = m_y[r_config_address.read()];
    29672777                    std::vector<data_t> data_vector;
    29682778                    data_vector.clear();
    2969                     for(size_t word=0; word<m_words; word++)
    2970                     {
    2971                         uint32_t data = m_cache_data.read( way, set, word );
    2972                         data_vector.push_back( data );
     2779                    for (size_t word = 0; word < m_words; word++)
     2780                    {
     2781                        uint32_t data = m_cache_data.read(way, set, word);
     2782                        data_vector.push_back(data);
    29732783                    }
    29742784
     
    29922802
    29932803#if DEBUG_MEMC_CONFIG
    2994                     if(m_debug)
     2804                    if (m_debug)
    29952805                        std::cout << "  <MEMC " << name() << " CONFIG_TRT_SET> PUT request in TRT:"
    29962806                            << " address = " << std::hex << r_config_address.read()
     
    30022812            case CONFIG_PUT_REQ:       // post PUT request to IXR_CMD_FSM
    30032813                {
    3004                     if ( not r_config_to_ixr_cmd_req.read() )
     2814                    if (not r_config_to_ixr_cmd_req.read())
    30052815                    {
    30062816                        r_config_to_ixr_cmd_req   = true;
     
    30082818
    30092819                        // prepare next iteration
    3010                         r_config_cmd_lines              = r_config_cmd_lines.read() - 1;
    3011                         r_config_address                = r_config_address.read() + (m_words<<2);
    3012                         r_config_fsm                    = CONFIG_LOOP;
     2820                        r_config_cmd_lines = r_config_cmd_lines.read() - 1;
     2821                        r_config_address   = r_config_address.read() + (m_words << 2);
     2822                        r_config_fsm       = CONFIG_LOOP;
    30132823
    30142824#if DEBUG_MEMC_CONFIG
    3015                         if(m_debug)
     2825                        if (m_debug)
    30162826                            std::cout << "  <MEMC " << name() << " CONFIG_PUT_REQ> post PUT request to IXR_CMD_FSM"
    30172827                                << " / address = " << std::hex << r_config_address.read() << std::endl;
     
    30272837                // directory if IVT not full.
    30282838                {
    3029                     assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
     2839                    assert((r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
    30302840                            "MEMC ERROR in CONFIG_IVT_LOCK state: bad DIR allocation");
    30312841
    3032                     if ( r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG )
     2842                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG)
    30332843                    {
    30342844                        size_t set        = m_y[(addr_t)(r_config_address.read())];
    30352845                        size_t way        = r_config_dir_way.read();
    30362846
    3037                         if ( r_config_dir_count.read() == 0 )     // inval DIR and return to LOOP
    3038                         {
    3039                             m_cache_directory.inval( way, set );
     2847                        if (r_config_dir_count.read() == 0)     // inval DIR and return to LOOP
     2848                        {
     2849                            m_cache_directory.inval(way, set);
    30402850                            r_config_cmd_lines  = r_config_cmd_lines.read() - 1;
    3041                             r_config_address    = r_config_address.read() + (m_words<<2);
     2851                            r_config_address    = r_config_address.read() + (m_words << 2);
    30422852                            r_config_fsm        = CONFIG_LOOP;
    30432853
    30442854#if DEBUG_MEMC_CONFIG
    3045                             if(m_debug)
     2855                            if (m_debug)
    30462856                                std::cout << "  <MEMC " << name() << " CONFIG_IVT_LOCK>"
    30472857                                    << " No copies in L1 : inval DIR entry"  << std::endl;
     
    30712881                                            index);
    30722882
    3073                             if ( wok )  // IVT success => inval DIR slot
     2883                            if (wok)  // IVT success => inval DIR slot
    30742884                            {
    3075                                 m_cache_directory.inval( way, set );
     2885                                m_cache_directory.inval(way, set);
    30762886                                r_config_ivt_index = index;
    30772887                                config_rsp_lines_incr = true;
    3078                                 if ( broadcast )  r_config_fsm = CONFIG_BC_SEND;
    3079                                 else              r_config_fsm = CONFIG_INVAL_SEND;
     2888                                if (broadcast)  r_config_fsm = CONFIG_BC_SEND;
     2889                                else             r_config_fsm = CONFIG_INVAL_SEND;
    30802890
    30812891#if DEBUG_MEMC_CONFIG
    3082                                 if(m_debug)
     2892                                if (m_debug)
    30832893                                    std::cout << "  <MEMC " << name() << " CONFIG_IVT_LOCK>"
    30842894                                        << " Inval DIR entry and register inval in IVT"
     
    30922902
    30932903#if DEBUG_MEMC_CONFIG
    3094                                 if(m_debug)
     2904                                if (m_debug)
    30952905                                    std::cout << "  <MEMC " << name() << " CONFIG_IVT_LOCK>"
    30962906                                        << " IVT full : release DIR & IVT locks and retry" << std::endl;
     
    31042914            case CONFIG_BC_SEND:    // Post a broadcast inval request to CC_SEND FSM
    31052915                {
    3106                     if( not r_config_to_cc_send_multi_req.read() and
    3107                             not r_config_to_cc_send_brdcast_req.read() )
     2916                    if (not r_config_to_cc_send_multi_req.read() and
     2917                            not r_config_to_cc_send_brdcast_req.read())
    31082918                    {
    31092919                        // post bc inval request
     
    31192929
    31202930#if DEBUG_MEMC_CONFIG
    3121                         if(m_debug)
     2931                        if (m_debug)
    31222932                            std::cout << "  <MEMC " << name() << " CONFIG_BC_SEND>"
    31232933                                << " Post a broadcast inval request to CC_SEND FSM"
     
    31302940            case CONFIG_INVAL_SEND:    // Post a multi inval request to CC_SEND FSM
    31312941                {
    3132                     if( not r_config_to_cc_send_multi_req.read() and
     2942                    if (not r_config_to_cc_send_multi_req.read() and
    31332943                            not r_config_to_cc_send_brdcast_req.read() )
    31342944                    {
     
    31432953                        config_to_cc_send_fifo_put      = true;
    31442954
    3145                         if ( r_config_dir_count.read() == 1 )  // one copy
     2955                        if (r_config_dir_count.read() == 1 )  // one copy
    31462956                        {
    31472957                            // prepare next iteration
     
    31562966
    31572967#if DEBUG_MEMC_CONFIG
    3158                         if(m_debug)
     2968                        if (m_debug)
    31592969                            std::cout << "  <MEMC " << name() << " CONFIG_INVAL_SEND>"
    31602970                                << " Post multi inval request to CC_SEND FSM"
     
    31692979            case CONFIG_HEAP_REQ:  // Try to get access to Heap
    31702980                {
    3171                     if ( r_alloc_heap_fsm.read() == ALLOC_HEAP_CONFIG )
    3172                     {
    3173                         r_config_fsm       = CONFIG_HEAP_SCAN;
     2981                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_CONFIG )
     2982                    {
     2983                        r_config_fsm = CONFIG_HEAP_SCAN;
    31742984                        r_config_heap_next = r_config_dir_ptr.read();
    31752985                    }
    31762986
    31772987#if DEBUG_MEMC_CONFIG
    3178                     if(m_debug)
     2988                    if (m_debug)
    31792989                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_REQ>"
    31802990                            << " Requesting HEAP lock" << std::endl;
     
    31933003                    config_to_cc_send_fifo_put   = true;
    31943004
    3195                     if ( m_config_to_cc_send_inst_fifo.wok() ) // inval request accepted
     3005                    if (m_config_to_cc_send_inst_fifo.wok()) // inval request accepted
    31963006                    {
    31973007                        r_config_heap_next = entry.next;
    3198                         if ( last_copy ) r_config_fsm = CONFIG_HEAP_LAST;
     3008                        if (last_copy) r_config_fsm = CONFIG_HEAP_LAST;
    31993009                    }
    32003010
    32013011#if DEBUG_MEMC_CONFIG
    3202                     if(m_debug)
     3012                    if (m_debug)
    32033013                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_SCAN>"
    32043014                            << " Post multi inval request to CC_SEND FSM"
     
    32173027                    last_entry.owner.inst  = false;
    32183028
    3219                     if ( m_heap.is_full() )
     3029                    if (m_heap.is_full())
    32203030                    {
    32213031                        last_entry.next = r_config_dir_ptr.read();
     
    32273037                    }
    32283038
    3229                     m_heap.write_free_ptr( r_config_dir_ptr.read() );
    3230                     m_heap.write( r_config_heap_next.read(), last_entry );
     3039                    m_heap.write_free_ptr(r_config_dir_ptr.read() );
     3040                    m_heap.write(r_config_heap_next.read(), last_entry );
    32313041
    32323042                    // prepare next iteration
    3233                     r_config_cmd_lines          = r_config_cmd_lines.read() - 1;
    3234                     r_config_address            = r_config_address.read() + (m_words<<2);
    3235                     r_config_fsm                = CONFIG_LOOP;
     3043                    r_config_cmd_lines = r_config_cmd_lines.read() - 1;
     3044                    r_config_address   = r_config_address.read() + (m_words<<2);
     3045                    r_config_fsm       = CONFIG_LOOP;
    32363046
    32373047#if DEBUG_MEMC_CONFIG
    3238                     if(m_debug)
     3048                    if (m_debug)
    32393049                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_LAST>"
    32403050                            << " Heap housekeeping" << std::endl;
     
    32723082            case READ_IDLE:  // waiting a read request
    32733083                {
    3274                     if(m_cmd_read_addr_fifo.rok())
     3084                    if (m_cmd_read_addr_fifo.rok())
    32753085                    {
    32763086
     
    32803090
    32813091#if DEBUG_MEMC_READ
    3282                         if(m_debug)
     3092                        if (m_debug)
    32833093                            std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
    32843094                                << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
     
    32983108            case READ_DIR_REQ:  // Get the lock to the directory
    32993109                {
    3300                     if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     3110                    if (r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    33013111                    {
    33023112                        r_read_fsm = READ_DIR_LOCK;
    3303                         m_cpt_read_fsm_n_dir_lock++;
    33043113                    }
    33053114
    33063115#if DEBUG_MEMC_READ
    3307                     if(m_debug)
     3116                    if (m_debug)
    33083117                        std::cout << "  <MEMC " << name() << " READ_DIR_REQ> Requesting DIR lock " << std::endl;
    33093118#endif
    3310 
    3311                     m_cpt_read_fsm_dir_lock++;
    3312 
    33133119                    break;
    33143120                }
     
    33233129                    DirectoryEntry entry =
    33243130                        m_cache_directory.read(m_cmd_read_addr_fifo.read(), way);
    3325                     if(((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) and not r_read_ll_done.read())   // access the global table ONLY when we have an LL cmd
    3326                     {
    3327                         r_read_ll_key   = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
     3131                    if (((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) and not r_read_ll_done.read())   // access the global table ONLY when we have an LL cmd
     3132                    {
     3133                        r_read_ll_key = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
    33283134                        /**//*std::cout << "MEMCACHE : from proc " << m_cmd_read_srcid_fifo.read()
    33293135                              << " | @ " << std::hex << m_cmd_read_addr_fifo.read()
     
    33313137                        r_read_ll_done  = true;
    33323138                    }
    3333 
    3334                     //bool s_getm_hit         = m_cmd_read_pktid_fifo.read() & 0x8;
    33353139
    33363140                    r_read_is_cnt           = entry.is_cnt;
     
    33503154                    bool cached_read = ((m_cmd_read_pktid_fifo.read() & 0x7) != 0) and ((m_cmd_read_pktid_fifo.read() & 0x7) != 0x2) and ((m_cmd_read_pktid_fifo.read() & 0x7) != 0x6);
    33513155
    3352                     if(entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE)    // hit
    3353                     {
    3354                         if ( (m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE )
     3156                    if (entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE)    // hit
     3157                    {
     3158                        if ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE )
    33553159                        {
    33563160                                // Invalid the line in the others processors and put the line in trt with data.
    3357                                 if(entry.count == 0) 
     3161                                if (entry.count == 0) 
    33583162                                  //  ((entry.count == 1) and not entry.is_cnt and (entry.state == ENTRY_SHARED) and (entry.owner.srcid == m_cmd_read_srcid_fifo.read())) or
    33593163                                  //  (entry.count == 1 and entry.is_cnt and entry.state == ENTRY_SHARED and s_getm_hit))
     
    33633167                                else
    33643168                                {
    3365                                     if((entry.state == ENTRY_EXCLUSIVE) and (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
     3169                                    if ((entry.state == ENTRY_EXCLUSIVE) and (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
    33663170                                    {
    33673171                                        std::cout <<"exclusive line && srcid != read srcid "<< std::endl;
     
    33723176
    33733177                                addr_t min = m_cmd_read_addr_fifo.read();
    3374                                 addr_t max = m_cmd_read_addr_fifo.read() + m_cmd_read_length_fifo.read()*4;
     3178                                addr_t max = m_cmd_read_addr_fifo.read() + m_cmd_read_length_fifo.read() * 4;
    33753179                                m_llsc_table.sw(min, max);
    33763180                        }
    33773181                        else // a read miss request
    33783182                        {
    3379                             if ( entry.state == ENTRY_SHARED or entry.count == 0)
     3183                            if (entry.state == ENTRY_SHARED or entry.count == 0)
    33803184                            {
    3381                                 if( entry.is_cnt or (entry.count == 0) or (not cached_read))
     3185                                if (entry.is_cnt or (entry.count == 0) or (not cached_read))
    33823186                                {
    33833187                                    r_read_fsm = READ_DIR_HIT;
     
    33883192                                }
    33893193                            }
    3390                             else if ( entry.state == ENTRY_EXCLUSIVE )
     3194                            else if (entry.state == ENTRY_EXCLUSIVE)
    33913195                            {
    33923196                                r_read_fsm = READ_IVT_UPDT_LOCK;
     
    33943198                        }
    33953199                    }
    3396                     else if(entry.state == ENTRY_LOCKED) // the line is locked, can't use it at this time
    3397                     {
    3398                         m_cpt_read_locked_rb ++;
     3200                    else if (entry.state == ENTRY_LOCKED) // the line is locked, can't use it at this time
     3201                    {
    33993202                        r_read_fsm = READ_WAIT;
    34003203                    }
     
    34053208
    34063209#if DEBUG_MEMC_READ
    3407                     if(m_debug)
     3210                    if (m_debug)
    34083211                    {
    34093212                        std::cout << "  <MEMC " << name() << " READ_DIR_LOCK> Accessing directory: "
     
    34153218                            << " / is_inst = " << entry.owner.inst
    34163219                            << " / is_cnt = " << entry.is_cnt << std::endl;
    3417                         if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) std::cout << " / LL access" << std::endl;
     3220                        if ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) std::cout << " / LL access" << std::endl;
    34183221                        else                                                std::cout << std::endl;
    34193222                    }
     
    34383241                        size_t ivt_send_count   = 0;
    34393242
    3440                         if( m_ivt.is_full() or // not need to check match inval, because of the LOCKED STATE
     3243                        if (m_ivt.is_full() or // not need to check match inval, because of the LOCKED STATE
    34413244                            r_read_to_cc_send_multi_req.read() or
    34423245                            r_read_to_cc_send_brdcast_req.read() or
     
    34463249                            r_read_fsm = READ_WAIT;
    34473250#if DEBUG_MEMC_READ
    3448                             if(m_debug)
     3251                            if (m_debug)
    34493252                            {
    34503253                                std::cout
     
    34753278                            //r_read_to_cc_send_is_shared     = r_read_state.read() == ENTRY_SHARED;
    34763279
    3477                             if(r_read_need_block.read())
     3280                            if (r_read_need_block.read())
    34783281                            {
    34793282                                r_read_to_cleanup_nline         = nline;
     
    35023305                                      index);
    35033306                               
    3504                             if( not_last_multi_req )
     3307                            if (not_last_multi_req )
    35053308                            {
    35063309                                r_read_fsm = READ_INVAL_HEAP_REQ;
     
    35123315                            }   
    35133316
    3514                             if(multi_req)
    3515                                 m_cpt_getm_minval ++;
    3516                             else
     3317                            // <Activity counters>
     3318                            if (!multi_req)
     3319                            {
    35173320                                m_cpt_getm_broadcast ++;
     3321                            }
     3322                            // </Activity counters>
    35183323#if DEBUG_MEMC_READ
    3519                             if(m_debug)
     3324                            if (m_debug)
    35203325                            {
    35213326                                std::cout
     
    35343339            case READ_INVAL_HEAP_REQ:
    35353340                {
    3536                     if( r_alloc_heap_fsm.read() == ALLOC_HEAP_READ )
     3341                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ )
    35373342                    {
    35383343                        r_read_fsm = READ_INVAL_HEAP_ERASE;
    35393344                    }
    35403345#if DEBUG_MEMC_READ
    3541                     if(m_debug)
     3346                    if (m_debug)
    35423347                        std::cout << "  <MEMC " << name() << " READ_INVAL_HEAP_REQ>"
    35433348                            << " Requesting HEAP lock" << std::endl;
     
    35483353            case READ_INVAL_HEAP_ERASE:
    35493354                {
    3550                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3355                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    35513356                    {
    35523357                        HeapEntry entry = m_heap.read(r_read_next_ptr.read());
     
    35573362                        r_read_next_ptr               = entry.next;
    35583363
    3559                         if(entry.next == r_read_next_ptr.read())   // last copy
     3364                        if (entry.next == r_read_next_ptr.read())   // last copy
    35603365                        {
    35613366                            r_read_to_cc_send_multi_req     = true;
     
    35683373
    35693374#if DEBUG_MEMC_READ
    3570                         if(m_debug)
     3375                        if (m_debug)
    35713376                            std::cout << "  <MEMC " << name() << " READ_HEAP_ERASE>"
    35723377                                << " Erase copy:"
     
    35803385            case READ_INVAL_HEAP_LAST:  // last copy
    35813386                {
    3582                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_READ)
     3387                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_READ)
    35833388                    {
    35843389                        std::cout << "VCI_MEM_CACHE ERROR " << name() << " READ_INVAL_HEAP_LAST"
     
    35913396                    last_entry.owner.srcid    = 0;
    35923397                    last_entry.owner.inst     = false;
    3593                     if(m_heap.is_full())
     3398                    if (m_heap.is_full())
    35943399                    {
    35953400                        last_entry.next     = r_read_next_ptr.read();
     
    36083413
    36093414#if DEBUG_MEMC_READ
    3610                     if(m_debug)
     3415                    if (m_debug)
    36113416                        std::cout << "  <MEMC " << name() << " READ_INVAL_HEAP_LAST>"
    36123417                            << " Heap housekeeping" << std::endl;
     
    36223427                        addr_t nline            = m_nline[(addr_t)(m_cmd_read_addr_fifo.read())];
    36233428                        size_t set              = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    3624                         if( m_ivt.is_full() or
     3429                        if (m_ivt.is_full() or
    36253430                            r_read_to_cc_send_multi_req.read() or
    36263431                            r_read_to_cc_send_brdcast_req.read() or
     
    36293434                            r_read_fsm = READ_WAIT;
    36303435#if DEBUG_MEMC_READ
    3631                             if(m_debug)
     3436                            if (m_debug)
    36323437                            {
    36333438                                std::cout
     
    36523457                            m_cache_directory.write(set, r_read_way.read(), entry);
    36533458                           
    3654                             if(r_read_need_block.read())
     3459                            if (r_read_need_block.read())
    36553460                            {
    36563461                                r_read_to_multi_ack_nline       = nline;
     
    36873492
    36883493#if DEBUG_MEMC_READ
    3689                             if(m_debug)
     3494                            if (m_debug)
    36903495                            {
    36913496                                 std::cout
     
    37093514                    r_read_fsm = READ_DIR_REQ;
    37103515#if DEBUG_MEMC_READ
    3711                     if(m_debug)
     3516                    if (m_debug)
    37123517                    {
    37133518                        std::cout
     
    37473552                    DirectoryEntry entry;
    37483553
    3749                     if(inst_read)
     3554                    if (inst_read)
    37503555                    {
    37513556                        entry.state = ENTRY_SHARED;
    37523557                    }
    3753                     else if(is_getm)
     3558                    else if (is_getm)
    37543559                    {
    37553560                        entry.state = ENTRY_EXCLUSIVE;
     
    37613566 
    37623567                    //entry.cache_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
    3763                     if( entry.state == ENTRY_SHARED) r_read_shared = true;
     3568                    if (entry.state == ENTRY_SHARED) r_read_shared = true;
    37643569                        else    r_read_shared = false;
    37653570                    entry.is_cnt  = is_cnt;
     
    37683573                    entry.lock    = r_read_lock.read();
    37693574                    entry.ptr     = r_read_ptr.read();
    3770                     if(cached_read)   // Cached read => we must update the copies
    3771                     {
    3772                         if(is_getm)
     3575                    if (cached_read)   // Cached read => we must update the copies
     3576                    {
     3577                        if (is_getm)
    37733578                        {
    37743579                            entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     
    37773582 
    37783583                        }
    3779                         else if(!is_cnt)  // Not counter mode
     3584                        else if (!is_cnt)  // Not counter mode
    37803585                        {
    37813586                            entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     
    37983603
    37993604#if DEBUG_MEMC_READ
    3800                     if(m_debug)
     3605                    if (m_debug)
    38013606                        std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    38023607                            << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
     
    38183623            case READ_HEAP_REQ:    // Get the lock to the HEAP directory
    38193624                {
    3820                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3625                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    38213626                    {
    38223627                        r_read_fsm = READ_HEAP_LOCK;
    3823                         m_cpt_read_fsm_n_heap_lock++;
    38243628                    }
    38253629
    38263630#if DEBUG_MEMC_READ
    3827                     if(m_debug)
     3631                    if (m_debug)
    38283632                        std::cout << "  <MEMC " << name() << " READ_HEAP_REQ>"
    38293633                            << " Requesting HEAP lock " << std::endl;
    38303634#endif
    3831 
    3832                     m_cpt_read_fsm_heap_lock++;
    3833 
    38343635                    break;
    38353636                }
     
    38393640                // and prepare the HEAP update
    38403641                {
    3841                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3642                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    38423643                    {
    38433644                        // enter counter mode when we reach the limit of copies or the heap is full
     
    38623663                        r_read_shared = true;  //ack to cache L1 with shared state
    38633664   
    3864                         if(not go_cnt)         // Not entering counter mode
     3665                        if (not go_cnt)         // Not entering counter mode
    38653666                        {
    38663667                            entry.owner.srcid    = r_read_copy.read();
     
    38783679
    38793680                        // prepare the heap update (add an entry, or clear the linked list)
    3880                         if(not go_cnt)      // not switching to counter mode
     3681                        if (not go_cnt)      // not switching to counter mode
    38813682                        {
    38823683                            // We test if the next free entry in the heap is the last
     
    38893690                        else            // switching to counter mode
    38903691                        {
    3891                             if(r_read_count.read() >1)              // heap must be cleared
     3692                            if (r_read_count.read() >1)              // heap must be cleared
    38923693                            {
    38933694                                HeapEntry next_entry = m_heap.read(r_read_ptr.read());
     
    38953696                                m_heap.write_free_ptr(r_read_ptr.read());
    38963697
    3897                                 if(next_entry.next == r_read_ptr.read())    // last entry
     3698                                if (next_entry.next == r_read_ptr.read())    // last entry
    38983699                                {
    38993700                                    r_read_fsm = READ_HEAP_LAST;    // erase the entry
     
    39123713
    39133714#if DEBUG_MEMC_READ
    3914                         if(m_debug)
     3715                        if (m_debug)
    39153716                            std::cout << "  <MEMC " << name() << " READ_HEAP_LOCK> Update directory:"
    39163717                                << " tag = " << std::hex << entry.tag
     
    39323733            case READ_HEAP_WRITE:       // add an entry in the heap
    39333734                {
    3934                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3735                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    39353736                    {
    39363737                        HeapEntry heap_entry;
     
    39383739                        heap_entry.owner.inst     = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    39393740
    3940                         if(r_read_count.read() == 1)  // creation of a new linked list
     3741                        if (r_read_count.read() == 1)  // creation of a new linked list
    39413742                        {
    39423743                            heap_entry.next         = m_heap.next_free_ptr();
     
    39483749                        m_heap.write_free_entry(heap_entry);
    39493750                        m_heap.write_free_ptr(r_read_next_ptr.read());
    3950                         if(r_read_last_free.read())  m_heap.set_full();
     3751                        if (r_read_last_free.read())  m_heap.set_full();
    39513752
    39523753                        r_read_fsm    = READ_RSP;
    39533754
    39543755#if DEBUG_MEMC_READ
    3955                         if(m_debug)
     3756                        if (m_debug)
    39563757                            std::cout << "  <MEMC " << name() << " READ_HEAP_WRITE> Add an entry in the heap:"
    39573758                                << " owner_id = " << std::hex << heap_entry.owner.srcid
     
    39703771            case READ_HEAP_ERASE:
    39713772                {
    3972                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3773                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    39733774                    {
    39743775                        HeapEntry next_entry = m_heap.read(r_read_ptr.read());
    3975                         if(next_entry.next == r_read_ptr.read())
     3776                        if (next_entry.next == r_read_ptr.read())
    39763777                        {
    39773778                            r_read_fsm = READ_HEAP_LAST;
     
    39953796            case READ_HEAP_LAST:
    39963797                {
    3997                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3798                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    39983799                    {
    39993800                        HeapEntry last_entry;
     
    40013802                        last_entry.owner.inst     = false;
    40023803
    4003                         if(m_heap.is_full())
     3804                        if (m_heap.is_full())
    40043805                        {
    40053806                            last_entry.next       = r_read_ptr.read();
     
    40243825            case READ_RSP:    //  request the TGT_RSP FSM to return data
    40253826                {
    4026                     if(not r_read_to_tgt_rsp_req.read())
     3827                    if (not r_read_to_tgt_rsp_req.read())
    40273828                    {
    40283829                        for(size_t i=0 ; i<m_words ; i++)  r_read_to_tgt_rsp_data[i] = r_read_data[i];
     
    40463847
    40473848#if DEBUG_MEMC_READ
    4048                         if(m_debug)
     3849                        if (m_debug)
    40493850                            std::cout << "  <MEMC " << name() << " READ_RSP> Request TGT_RSP FSM to return data:"
    40503851                                << " rsrcid = " << std::hex << m_cmd_read_srcid_fifo.read()
     
    40583859            case READ_TRT_LOCK: // read miss : check the Transaction Table
    40593860                {
    4060                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
     3861                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
    40613862                    {
    40623863                        size_t      index     = 0;
     
    40673868                        bool        wok       = !m_trt.full(index);
    40683869                       
    4069                         //if(hit_write) m_trt.print(index_write);
    4070                         if(hit_read or !wok or hit_write)    // missing line already requested or no space
    4071                         {
    4072                             if(!wok)
     3870                        //if (hit_write) m_trt.print(index_write);
     3871                        if (hit_read or !wok or hit_write)    // missing line already requested or no space
     3872                        {
     3873                            // <Activity counters>
     3874                            if (!wok)
    40733875                            {
    40743876                                m_cpt_trt_full++;
    40753877                            }
    4076                             if(hit_read or hit_write)   m_cpt_trt_rb++;
     3878                            if (hit_read or hit_write)
     3879                            {
     3880                                m_cpt_trt_rb++;
     3881                            }
     3882                            // </Activity counters>
    40773883                            r_read_fsm = READ_IDLE;
    40783884                        }
    4079                         else                  // missing line is requested to the XRAM
    4080                         {
    4081 
    4082                             if ( (m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE )
    4083                                 m_cpt_getm_miss ++;
    4084                             else
     3885                        else // missing line is requested to the XRAM
     3886                        {
     3887
     3888                            // <Activity counters>
     3889                            if ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE) {
     3890                                m_cpt_getm_miss++;
     3891                            }
     3892                            else {
    40853893                                m_cpt_read_miss++;
     3894                            }
     3895                            // </Activity counters>
    40863896
    40873897                            r_read_trt_index = index;
     
    40903900
    40913901#if DEBUG_MEMC_READ
    4092                         if(m_debug)
     3902                        if (m_debug)
    40933903                            std::cout << "  <MEMC " << name() << " READ_TRT_LOCK> Check TRT:"
    40943904                                << " hit_read = " << hit_read
    40953905                                << " / hit_write = " << hit_write
    40963906                                << " / full = " << !wok << std::endl;
    4097                         m_cpt_read_fsm_n_trt_lock++;
    4098 #endif
    4099                     }
    4100 
    4101                     m_cpt_read_fsm_trt_lock++;
    4102 
     3907#endif
     3908                    }
    41033909                    break;
    41043910                }
     
    41073913            case READ_TRT_SET:      // register get transaction in TRT
    41083914                {
    4109                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
     3915                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
    41103916                    {
    41113917                        m_trt.set(r_read_trt_index.read(),
     
    41233929
    41243930#if DEBUG_MEMC_READ
    4125                         if(m_debug)
     3931                        if (m_debug)
    41263932                            std::cout << "  <MEMC " << name() << " READ_TRT_SET> Set a GET in TGT:"
    41273933                                << " address = " << std::hex << m_cmd_read_addr_fifo.read()
     
    41363942            case READ_TRT_REQ:   // consume the read request in FIFO and send it to IXR_CMD_FSM
    41373943                {
    4138                     if(not r_read_to_ixr_cmd_req)
     3944                    if (not r_read_to_ixr_cmd_req)
    41393945                    {
    41403946                        cmd_read_fifo_get       = true;
     
    41453951
    41463952#if DEBUG_MEMC_READ
    4147                         if(m_debug)
     3953                        if (m_debug)
    41483954                            std::cout << "  <MEMC " << name() << " READ_TRT_REQ> Request GET transaction for address "
    41493955                                << std::hex << m_cmd_read_addr_fifo.read() << std::endl;
     
    42174023                    for(size_t word=0 ; word<m_words ; word++)
    42184024                    {
    4219                         if(word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
     4025                        if (word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
    42204026                        else              r_write_be[word] = 0x0;
    42214027                    }
     
    42314037
    42324038#if DEBUG_MEMC_WRITE
    4233                     if(m_debug)
     4039                    if (m_debug)
    42344040                        std::cout << "  <MEMC " << name() << " WRITE_IDLE> Write request "
    42354041                            << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
     
    42954101                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE )
    42964102                    {
    4297                         m_cpt_write_fsm_n_dir_lock ++;
    42984103                        break;
    42994104                    }
     
    43264131                    }
    43274132
    4328                     m_cpt_write_fsm_dir_lock ++;
    4329 
    43304133#if DEBUG_MEMC_WRITE
    4331                     if(m_debug)
     4134                    if (m_debug)
    43324135                        std::cout << "  <MEMC " << name() << " WRITE_DIR_REQ> Requesting DIR lock "
    43334136                            << std::endl;
     
    43444147                    DirectoryEntry entry(m_cache_directory.read(r_write_address.read(), way));
    43454148
    4346                     if(entry.state != ENTRY_INVALID)    // hit
     4149                    if (entry.state != ENTRY_INVALID)    // hit
    43474150                    {
    43484151                        // copy directory entry in local buffer in case of hit
     
    43574160                        r_write_state      = entry.state;
    43584161
    4359                         if( r_write_pktid == TYPE_DATA_UNC and entry.count != 0)
     4162                        if (r_write_pktid == TYPE_DATA_UNC and entry.count != 0)
    43604163                        {
    43614164                            assert( false && " found a copy for an uncached write quest");
     
    43634166                        else
    43644167                        {
    4365                             if( not entry.count and (entry.state != ENTRY_LOCKED))
     4168                            if (not entry.count and (entry.state != ENTRY_LOCKED))
    43664169                            {
    43674170                                r_write_fsm = WRITE_DIR_HIT;   
     
    43694172                            else if (entry.state == ENTRY_LOCKED)//the line is locked
    43704173                            {
    4371                                 m_cpt_write_locked_rb ++;
    43724174                                r_write_fsm = WRITE_WAIT;
    43734175                            }
     
    43844186
    43854187#if DEBUG_MEMC_WRITE
    4386                     if(m_debug)
     4188                    if (m_debug)
    43874189                    {
    43884190                        std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> Check the directory: "
     
    43914193                            << " / count = " << entry.count
    43924194                            << " / is_cnt = " << entry.is_cnt ;
    4393                         if((r_write_pktid.read() & 0x7) == TYPE_SC)
     4195                        if ((r_write_pktid.read() & 0x7) == TYPE_SC)
    43944196                            std::cout << " / SC access" << std::endl;
    43954197                        else
     
    44394241
    44404242#if DEBUG_MEMC_WRITE
    4441                     if(m_debug)
     4243                    if (m_debug)
    44424244                    {
    44434245                         std::cout << "  <MEMC " << name()
     
    44514253            case WRITE_HEAP_REQ:    // Get the lock to the HEAP directory
    44524254                {
    4453                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
     4255                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
    44544256                    {
    44554257                        r_write_fsm = WRITE_HEAP_ERASE;
    4456                         m_cpt_write_fsm_n_heap_lock++;
    44574258                    }
    44584259
    44594260#if DEBUG_MEMC_WRITE
    4460                     if(m_debug)
     4261                    if (m_debug)
    44614262                        std::cout << "  <MEMC " << name() << " WRITE_HEAP_REQ>"
    44624263                            << " Requesting HEAP lock " << std::endl;
    44634264#endif
    4464 
    4465                     m_cpt_write_fsm_heap_lock++;
    4466 
    44674265                    break;
    44684266                }
     
    44714269            case WRITE_HEAP_ERASE:   // get access to heap
    44724270                {
    4473                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
     4271                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
    44744272                    {
    44754273                        HeapEntry entry = m_heap.read(r_write_next_ptr.read());
     
    44784276                        write_to_cc_send_fifo_inst     = entry.owner.inst;
    44794277                        write_to_cc_send_fifo_put      = true;
    4480                         if(m_write_to_cc_send_inst_fifo.wok())
     4278                        if (m_write_to_cc_send_inst_fifo.wok())
    44814279                        {
    44824280                            r_write_next_ptr = entry.next;
    4483                             if(entry.next == r_write_next_ptr.read())   // last copy
     4281                            if (entry.next == r_write_next_ptr.read())   // last copy
    44844282                            {
    44854283                                r_write_to_cc_send_multi_req = true;
     
    44974295
    44984296#if DEBUG_MEMC_WRITE
    4499                         if(m_debug)
     4297                        if (m_debug)
    45004298                            std::cout << "  <MEMC " << name()
    45014299                                << " WRITE_HEAP_LOCK> Get acces to the HEAP" << std::endl;
    45024300#endif
    45034301                    }
    4504 
    4505                     m_cpt_write_fsm_heap_lock++;
    4506 
    45074302                    break;
    45084303                }
     
    45104305            case WRITE_HEAP_LAST:  // last copy
    45114306                {
    4512                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_WRITE)
     4307                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_WRITE)
    45134308                    {
    45144309                        std::cout << "VCI_MEM_CACHE ERROR " << name() << " WRITE_HEAP_LAST"
     
    45214316                    last_entry.owner.srcid    = 0;
    45224317                    last_entry.owner.inst     = false;
    4523                     if(m_heap.is_full())
     4318                    if (m_heap.is_full())
    45244319                    {
    45254320                        last_entry.next     = r_write_next_ptr.read();
     
    45374332
    45384333#if DEBUG_MEMC_XRAM_RSP
    4539                     if(m_debug)
     4334                    if (m_debug)
    45404335                        std::cout << "  <MEMC " << name() << " WRITE_HEAP_LAST>"
    45414336                            << " Heap housekeeping" << std::endl;
     
    45924387                            for(size_t word=0 ; word<m_words ; word++)
    45934388                            {
    4594                                 if(word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
     4389                                if (word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
    45954390                                else              r_write_be[word] = 0x0;
    45964391                            }
    45974392
    4598                             if( m_cmd_write_eop_fifo.read())
     4393                            if (m_cmd_write_eop_fifo.read())
    45994394                            {
    46004395                                r_write_fsm = WRITE_DIR_REQ;
     
    46074402
    46084403#if DEBUG_MEMC_WRITE
    4609                         if(m_debug)
     4404                        if (m_debug)
    46104405                        {
    46114406                            std::cout << "  <MEMC " << name() << " WRITE_RSP> Post a request to TGT_RSP FSM"
     
    46144409                                << " : sc_fail= " << std::hex << r_write_sc_fail.read()
    46154410                                << std::endl;
    4616                             if(m_cmd_write_addr_fifo.rok())
     4411                            if (m_cmd_write_addr_fifo.rok())
    46174412                            {
    46184413                                std::cout << "                    New Write request: "
     
    46314426            case WRITE_MISS_TRT_LOCK: // Miss : check Transaction Table
    46324427                {
    4633                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
     4428                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    46344429                    {
    46354430                        size_t  hit_index = 0;
     
    46404435                        bool    wok       = not m_trt.full(wok_index);
    46414436#if DEBUG_MEMC_WRITE
    4642                         if(m_debug)
     4437                        if (m_debug)
    46434438                            std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_LOCK> Check the TRT"
    46444439                                      << "hit read =" << hit_read
     
    46494444
    46504445                        // wait an empty entry in TRT
    4651                         if(not hit_read and (not wok or hit_write))
     4446                        if (not hit_read and (not wok or hit_write))
    46524447                        {
    46534448                            r_write_fsm       = WRITE_WAIT;
     4449                            // <Activity counters>
    46544450                            m_cpt_trt_full++;
    4655 
     4451                            // </Activity counters>
    46564452                            break;
    46574453                        }
     
    46684464                            r_write_trt_index = hit_index;
    46694465                            r_write_fsm       = WRITE_MISS_TRT_DATA;
     4466                            // <Activity counters>
    46704467                            m_cpt_write_miss++;
     4468                            // </Activity counters>
    46714469                            break;
    46724470                        }
     
    46764474                            r_write_trt_index = wok_index;
    46774475                            r_write_fsm       = WRITE_MISS_TRT_SET;
     4476                            // <Activity counters>
    46784477                            m_cpt_write_miss++;
     4478                            // </Activity counters>
    46794479                            break;
    46804480                        }
    46814481
    4682                         m_cpt_write_fsm_n_trt_lock ++;
    46834482                        assert(false && "VCI_MEM_CACHE ERROR: this part must not be reached");
    46844483                    }
     
    46924491
    46934492#if DEBUG_MEMC_WRITE
    4694                     if(m_debug)
     4493                    if (m_debug)
    46954494                        std::cout << "  <MEMC " << name() << " WRITE_WAIT> Releases the locks before retry" << std::endl;
    46964495#endif
     
    47024501            case WRITE_MISS_TRT_SET:  // register a new transaction in TRT (Write Buffer)
    47034502                {
    4704                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
     4503                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    47054504                    {
    47064505                        std::vector<be_t>   be_vector;
     
    47274526
    47284527#if DEBUG_MEMC_WRITE
    4729                         if(m_debug)
     4528                        if (m_debug)
    47304529                            std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_SET> Set a new entry in TRT" << std::endl;
    47314530#endif
     
    47374536            case WRITE_MISS_TRT_DATA: // update an entry in TRT (used as a Write Buffer)
    47384537                {
    4739                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
     4538                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    47404539                    {
    47414540                        std::vector<be_t> be_vector;
     
    47544553
    47554554#if DEBUG_MEMC_WRITE
    4756                         if(m_debug)
     4555                        if (m_debug)
    47574556                            std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_DATA> Modify an existing entry in TRT" << std::endl;
    47584557#endif
     
    47644563            case WRITE_MISS_XRAM_REQ: // send a GET request to IXR_CMD FSM
    47654564                {
    4766                     if(not r_write_to_ixr_cmd_req.read())
     4565                    if (not r_write_to_ixr_cmd_req.read())
    47674566                    {
    47684567                        r_write_to_ixr_cmd_req   = true;
     
    47714570
    47724571#if DEBUG_MEMC_WRITE
    4773                         if(m_debug)
     4572                        if (m_debug)
    47744573                            std::cout << "  <MEMC " << name()
    47754574                                << " WRITE_MISS_XRAM_REQ> Post a GET request to the"
     
    47964595                                           // (r_write_inval_trt_send.read() or not r_write_to_cleanup_req.read());
    47974596
    4798                     if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
     4597                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    47994598                    {
    48004599                        bool        wok        = false;
     
    48104609                        //r_write_ivt_index = index;
    48114610
    4812                         if(not ivt_full and cc_send_valid) //avoid to deadlock, we make sure that we can send cc_send request.
     4611                        if (not ivt_full and cc_send_valid) //avoid to deadlock, we make sure that we can send cc_send request.
    48134612                        { 
    48144613                            wok = m_ivt.set(false,        // it's an inval transaction
     
    48244623                                            index);
    48254624
    4826                             if(is_brdcast)
    4827                                 m_cpt_write_broadcast ++;
    4828                             else
    4829                                 m_cpt_write_minval ++;
     4625                            // <Activity counters>
     4626                            if (is_brdcast)
     4627                            {
     4628                                m_cpt_write_broadcast++;
     4629                            }
     4630                            // </Activity counters>
     4631
    48304632#if DEBUG_MEMC_WRITE
    4831                         if( m_debug and wok )
     4633                        if (m_debug and wok )
    48324634                            std::cout << "  <MEMC " << name() << " WRITE_INVAL_IVT_LOCK> Register broadcast inval in IVT"
    48334635                                << "ivt index = " << index
     
    48564658                            {
    48574659                               
    4858                                 if(r_write_state.read() == ENTRY_SHARED)
     4660                                if (r_write_state.read() == ENTRY_SHARED)
    48594661                                {
    48604662                                    m_cache_data.write(way, set, word, r_write_data[word].read(), r_write_be[word].read());
     
    48804682            case WRITE_INVAL_CC_SEND:    // Post a coherence broadcast request to CC_SEND FSM
    48814683                {
    4882                     if( not r_write_to_cc_send_multi_req.read()   and
     4684                    if (not r_write_to_cc_send_multi_req.read()   and
    48834685                        not r_write_to_cc_send_brdcast_req.read())
    48844686                    {
     
    48944696                        r_write_next_ptr               = r_write_ptr.read();
    48954697
    4896                         if(r_write_state.read() == ENTRY_EXCLUSIVE)
     4698                        if (r_write_state.read() == ENTRY_EXCLUSIVE)
    48974699                        {
    48984700                            r_write_to_cleanup_req   = true;
     
    49004702                        }
    49014703
    4902                         if( not last_multi_inval and multi_inval)
     4704                        if (not last_multi_inval and multi_inval)
    49034705                        {
    49044706                            r_write_fsm = WRITE_HEAP_REQ;
     
    49094711                        }
    49104712#if DEBUG_MEMC_WRITE
    4911                         if(m_debug)
     4713                        if (m_debug)
    49124714                            std::cout << "  <MEMC " << name()
    49134715                                << " WRITE_INVAL_CC_SEND> Post a inval request to CC_SEND FSM" << std::endl;
     
    49484750            case IXR_CMD_READ_IDLE:
    49494751                if     (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4950                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4951                 else if(r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4952                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4953                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4954                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4752                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4753                else if (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4754                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4755                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4756                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    49554757                break;
    49564758                ////////////////////////
    49574759            case IXR_CMD_WRITE_IDLE:
    49584760                if     (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4959                 else if(r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4960                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4961                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4962                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4963                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4761                else if (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4762                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4763                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4764                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4765                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    49644766                break;
    49654767                ////////////////////////
    49664768            case IXR_CMD_CAS_IDLE:
    49674769                if     (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4968                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4969                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4970                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4971                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4972                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4770                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4771                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4772                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4773                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4774                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    49734775                break;
    49744776                ////////////////////////
    49754777            case IXR_CMD_XRAM_IDLE:
    49764778                if     (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4977                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4978                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4979                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4980                 else if(r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4981                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4779                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4780                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4781                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4782                else if (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4783                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    49824784                break;
    49834785                ////////////////////////
    49844786            case IXR_CMD_CLEANUP_IDLE:
    49854787                if     (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4986                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4987                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4988                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4989                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4990                 else if(r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4788                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4789                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4790                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4791                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4792                else if (r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    49914793                break;     
    49924794                /////////////////////////
     
    49944796                {
    49954797                    if     (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4996                     else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4997                     else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4998                     else if(r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4999                     else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    5000                     else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4798                    else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4799                    else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4800                    else if (r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4801                    else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4802                    else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    50014803                    break;
    50024804                }
     
    50054807            case IXR_CMD_READ_TRT:       // access TRT for a GET
    50064808                {
    5007                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4809                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50084810                    {
    50094811                        TransactionTabEntry entry = m_trt.read( r_read_to_ixr_cmd_index.read() );
     
    50154817
    50164818#if DEBUG_MEMC_IXR_CMD
    5017                         if(m_debug)
     4819                        if (m_debug)
    50184820                            std::cout << "  <MEMC " << name() << " IXR_CMD_READ_TRT> TRT access"
    50194821                                << " index = " << std::dec << r_read_to_ixr_cmd_index.read()
     
    50264828            case IXR_CMD_WRITE_TRT:       // access TRT for a PUT or a GET
    50274829                {
    5028                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4830                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50294831                    {
    50304832                        TransactionTabEntry entry = m_trt.read( r_write_to_ixr_cmd_index.read() );
     
    50424844
    50434845#if DEBUG_MEMC_IXR_CMD
    5044                         if(m_debug)
     4846                        if (m_debug)
    50454847                            std::cout << "  <MEMC " << name() << " IXR_CMD_WRITE_TRT> TRT access"
    50464848                                << " index = " << std::dec << r_write_to_ixr_cmd_index.read()
     
    50534855            case IXR_CMD_CAS_TRT:       // access TRT for a PUT or a GET
    50544856                {
    5055                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4857                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50564858                    {
    50574859                        TransactionTabEntry entry = m_trt.read( r_cas_to_ixr_cmd_index.read() );
     
    50694871
    50704872#if DEBUG_MEMC_IXR_CMD
    5071                         if(m_debug)
     4873                        if (m_debug)
    50724874                            std::cout << "  <MEMC " << name() << " IXR_CMD_CAS_TRT> TRT access"
    50734875                                << " index = " << std::dec << r_cas_to_ixr_cmd_index.read()
     
    50804882            case IXR_CMD_XRAM_TRT:       // access TRT for a PUT
    50814883                {
    5082                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4884                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50834885                    {
    50844886                        TransactionTabEntry entry = m_trt.read( r_xram_rsp_to_ixr_cmd_index.read() );
     
    50894891                        r_ixr_cmd_fsm     = IXR_CMD_XRAM_SEND;
    50904892                        for( size_t i=0 ; i<m_words ; i++ ) r_ixr_cmd_wdata[i] = entry.wdata[i];
    5091 
    5092                         m_cpt_ixr_cmd_fsm_n_trt_lock ++;
    50934893#if DEBUG_MEMC_IXR_CMD
    5094                         if(m_debug)
     4894                        if (m_debug)
    50954895                            std::cout << "  <MEMC " << name() << " IXR_CMD_XRAM_TRT> TRT access"
    50964896                                << " index = " << std::dec << r_xram_rsp_to_ixr_cmd_index.read()
     
    51034903            case IXR_CMD_CLEANUP_TRT:       // access TRT for a PUT
    51044904                {
    5105                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4905                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    51064906                    {
    51074907
     
    51154915
    51164916#if DEBUG_MEMC_IXR_CMD
    5117                         if(m_debug)
     4917                        if (m_debug)
    51184918                            std::cout << "  <MEMC " << name() << " IXR_CMD_CLEANUP_TRT> TRT access"
    51194919                                << " index = " << std::dec << r_cleanup_to_ixr_cmd_index.read()
     
    51264926            case IXR_CMD_CONFIG_TRT:       // access TRT for a PUT
    51274927                {
    5128                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4928                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    51294929                    {
    51304930                        TransactionTabEntry entry = m_trt.read( r_config_to_ixr_cmd_index.read() );
     
    51374937
    51384938#if DEBUG_MEMC_IXR_CMD
    5139                         if(m_debug)
     4939                        if (m_debug)
    51404940                            std::cout << "  <MEMC " << name() << " IXR_CMD_CONFIG_TRT> TRT access"
    51414941                                << " index = " << std::dec << r_config_to_ixr_cmd_index.read()
     
    51494949            case IXR_CMD_READ_SEND:      // send a get from READ FSM
    51504950                {
    5151                     if(p_vci_ixr.cmdack)
     4951                    if (p_vci_ixr.cmdack)
    51524952                    {
    51534953                        r_ixr_cmd_fsm         = IXR_CMD_READ_IDLE;
     
    51554955
    51564956#if DEBUG_MEMC_IXR_CMD
    5157                         if(m_debug)
     4957                        if (m_debug)
    51584958                            std::cout << "  <MEMC " << name() << " IXR_CMD_READ_SEND> GET request:" << std::hex
    51594959                                << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    51654965            case IXR_CMD_WRITE_SEND:     // send a put or get from WRITE FSM
    51664966                {
    5167                     if(p_vci_ixr.cmdack)
     4967                    if (p_vci_ixr.cmdack)
    51684968                    {
    51694969                        if (not r_ixr_cmd_get.read())   // PUT
    51704970                        {
    5171                             if(r_ixr_cmd_word.read() == (m_words - 2))
     4971                            if (r_ixr_cmd_word.read() == (m_words - 2))
    51724972                            {
    51734973                                r_ixr_cmd_fsm          = IXR_CMD_WRITE_IDLE;
     
    51804980
    51814981#if DEBUG_MEMC_IXR_CMD
    5182                             if(m_debug)
     4982                            if (m_debug)
    51834983                                std::cout << "  <MEMC " << name() << " IXR_CMD_WRITE_SEND> PUT request:" << std::hex
    51844984                                    << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    51914991
    51924992#if DEBUG_MEMC_IXR_CMD
    5193                             if(m_debug)
     4993                            if (m_debug)
    51944994                                std::cout << "  <MEMC " << name() << " IXR_CMD_WRITE_SEND> GET request:" << std::hex
    51954995                                    << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    52025002            case IXR_CMD_CAS_SEND:      // send a put or get command from CAS FSM
    52035003                {
    5204                     if(p_vci_ixr.cmdack)
     5004                    if (p_vci_ixr.cmdack)
    52055005                    {
    52065006                        if (not r_ixr_cmd_get.read()) // PUT
    52075007                        {
    5208                             if(r_ixr_cmd_word.read() == (m_words - 2))
     5008                            if (r_ixr_cmd_word.read() == (m_words - 2))
    52095009                            {
    52105010                                r_ixr_cmd_fsm        = IXR_CMD_CAS_IDLE;
     
    52175017
    52185018#if DEBUG_MEMC_IXR_CMD
    5219                             if(m_debug)
     5019                            if (m_debug)
    52205020                                std::cout << "  <MEMC " << name() << " IXR_CMD_CAS_SEND> PUT request:" << std::hex
    52215021                                    << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    52285028
    52295029#if DEBUG_MEMC_IXR_CMD
    5230                             if(m_debug)
     5030                            if (m_debug)
    52315031                                std::cout << "  <MEMC " << name() << " IXR_CMD_CAS_SEND> GET request:" << std::hex
    52325032                                    << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    52395039            case IXR_CMD_XRAM_SEND:     // send a put from XRAM_RSP FSM
    52405040                {
    5241                     if(p_vci_ixr.cmdack.read())
    5242                     {
    5243                         if(r_ixr_cmd_word.read() == (m_words - 2))
     5041                    if (p_vci_ixr.cmdack.read())
     5042                    {
     5043                        if (r_ixr_cmd_word.read() == (m_words - 2))
    52445044                        {
    52455045                            r_ixr_cmd_fsm = IXR_CMD_XRAM_IDLE;
     
    52515051                        }
    52525052#if DEBUG_MEMC_IXR_CMD
    5253                         if(m_debug)
     5053                        if (m_debug)
    52545054                            std::cout << "  <MEMC " << name() << " IXR_CMD_XRAM_SEND> PUT request:" << std::hex
    52555055                                << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    52625062            case IXR_CMD_CLEANUP_DATA_SEND:     // send a put command to XRAM
    52635063                {
    5264                     if(p_vci_ixr.cmdack.read())
    5265                     {
    5266                         if(r_ixr_cmd_word.read() == (m_words - 2))
     5064                    if (p_vci_ixr.cmdack.read())
     5065                    {
     5066                        if (r_ixr_cmd_word.read() == (m_words - 2))
    52675067                        {
    52685068                            r_ixr_cmd_fsm = IXR_CMD_CLEANUP_IDLE;
     
    52775077
    52785078#if DEBUG_MEMC_IXR_CMD
    5279                         if(m_debug)
     5079                        if (m_debug)
    52805080                        {
    52815081                            std::cout << "  <MEMC " << name() << ".IXR_CMD_CLEANUP_DATA_SEND> Send a put request to xram" << std::endl;
     
    52895089            case IXR_CMD_CONFIG_SEND:     // send a put from CONFIG FSM
    52905090                {
    5291                     if(p_vci_ixr.cmdack.read())
    5292                     {
    5293                         if(r_ixr_cmd_word.read() == (m_words - 2))
     5091                    if (p_vci_ixr.cmdack.read())
     5092                    {
     5093                        if (r_ixr_cmd_word.read() == (m_words - 2))
    52945094                        {
    52955095                            r_ixr_cmd_fsm = IXR_CMD_CONFIG_IDLE;
     
    53025102
    53035103#if DEBUG_MEMC_IXR_CMD
    5304                         if(m_debug)
     5104                        if (m_debug)
    53055105                            std::cout << "  <MEMC " << name() << " IXR_CMD_CONFIG_SEND> PUT request:" << std::hex
    53065106                                << " address = " << r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2) << std::endl;
     
    53375137            case IXR_RSP_IDLE:  // test transaction type: PUT/GET
    53385138                {
    5339                     if(p_vci_ixr.rspval.read())
     5139                    if (p_vci_ixr.rspval.read())
    53405140                    {
    53415141                        r_ixr_rsp_cpt       = 0;
     
    53455145                                "MEMC ERROR in IXR_RSP state: XRAM response error !");
    53465146
    5347                         if(p_vci_ixr.reop.read())   // PUT
     5147                        if (p_vci_ixr.reop.read())   // PUT
    53485148                        {
    53495149                            r_ixr_rsp_fsm = IXR_RSP_TRT_ERASE;
     
    53555155
    53565156#if DEBUG_MEMC_IXR_RSP
    5357                             if(m_debug)
     5157                            if (m_debug)
    53585158                                std::cout << "  <MEMC " << name()
    53595159                                    << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
     
    53745174                // decrease the line counter if config request
    53755175                {
    5376                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
     5176                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
    53775177                    {
    53785178                        size_t  index = r_ixr_rsp_trt_index.read();
     
    53885188                            r_ixr_rsp_fsm = IXR_RSP_IDLE;
    53895189                        }
    5390 
    5391                         m_cpt_ixr_rsp_fsm_n_trt_lock ++;
    53925190#if DEBUG_MEMC_IXR_RSP
    5393                         if(m_debug)
     5191                        if (m_debug)
    53945192                            std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
    53955193                                << r_ixr_rsp_trt_index.read() << std::endl;
     
    54015199            case IXR_RSP_TRT_READ:    // write a 64 bits data in the TRT
    54025200                {
    5403                     if((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
     5201                    if ((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
    54045202                    {
    54055203                        size_t      index    = r_ixr_rsp_trt_index.read();
     
    54185216                        r_ixr_rsp_cpt = word + 2;
    54195217
    5420                         if(eop)
     5218                        if (eop)
    54215219                        {
    54225220                            r_ixr_rsp_to_xram_rsp_rok[r_ixr_rsp_trt_index.read()]=true;
     
    54255223
    54265224#if DEBUG_MEMC_IXR_RSP
    5427                         if(m_debug)
     5225                        if (m_debug)
    54285226                            std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing a word in TRT : "
    54295227                                << " index = " << std::dec << index
     
    54315229                                << " / data = " << std::hex << data << std::endl;
    54325230#endif
    5433                         m_cpt_ixr_rsp_fsm_n_trt_lock ++;
    5434                     }
    5435                     m_cpt_ixr_fsm_trt_lock++;
     5231                    }
    54365232                    break;
    54375233                }
     
    54715267                    {
    54725268                        size_t index = (i+old+1) %lines;
    5473                         if(r_ixr_rsp_to_xram_rsp_rok[index])
     5269                        if (r_ixr_rsp_to_xram_rsp_rok[index])
    54745270                        {
    54755271                            r_xram_rsp_trt_index             = index;
     
    54785274
    54795275#if DEBUG_MEMC_XRAM_RSP
    5480                             if(m_debug)
     5276                            if (m_debug)
    54815277                                std::cout << "  <MEMC " << name() << " XRAM_RSP_IDLE>"
    54825278                                    << " Available cache line in TRT:"
     
    54925288                // Copy the TRT entry in a local buffer
    54935289                {
    5494                     if((r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP) and
     5290                    if ((r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP) and
    54955291                            (r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP))
    54965292                    {
     
    55015297
    55025298#if DEBUG_MEMC_XRAM_RSP
    5503                         if(m_debug)
     5299                        if (m_debug)
    55045300                            std::cout << "  <MEMC " << name() << " XRAM_RSP_DIR_LOCK>"
    55055301                                << " Get access to DIR and TRT" << std::endl;
    55065302#endif
    5507                         m_cpt_xram_rsp_fsm_n_dir_lock++;
    5508                         m_cpt_xram_rsp_fsm_n_trt_lock++;
    5509                     }
    5510                     m_cpt_xram_rsp_fsm_dir_lock++;
    5511                     m_cpt_xram_rsp_fsm_trt_lock++;
     5303                    }
    55125304                    break;
    55135305                }
     
    55285320                    DirectoryEntry victim(m_cache_directory.select(set, way));
    55295321
    5530                     if( way == -1)
     5322                    if (way == -1)
    55315323                    {
    55325324#if DEBUG_MEMC_XRAM_RSP
    5533                     if(m_debug)
     5325                    if (m_debug)
    55345326                        std::cout << "  <MEMC " << name() << " XRAM_RSP_TRT_COPY>"
    55355327                            << " not a disponible victim"
     
    55595351                    assert( victim.state != ENTRY_LOCKED && "XRAM RSP SELECTED A LOCKED VICTIM ");
    55605352
    5561                     if( not r_xram_rsp_trt_buf.rerror ) r_xram_rsp_fsm = XRAM_RSP_IVT_LOCK;
     5353                    if (not r_xram_rsp_trt_buf.rerror ) r_xram_rsp_fsm = XRAM_RSP_IVT_LOCK;
    55625354                    else                                r_xram_rsp_fsm = XRAM_RSP_ERROR_ERASE;
    55635355                   
    55645356#if DEBUG_MEMC_XRAM_RSP
    5565                     if(m_debug)
     5357                    if (m_debug)
    55665358                        std::cout << "  <MEMC " << name() << " XRAM_RSP_TRT_COPY>"
    55675359                            << " Select a victim slot: "
     
    55855377                            "MEMC ERROR in XRAM_RSP_IVT_LOCK state: Bad TRT allocation");
    55865378
    5587                     if(r_alloc_ivt_fsm == ALLOC_IVT_XRAM_RSP)
     5379                    if (r_alloc_ivt_fsm == ALLOC_IVT_XRAM_RSP)
    55885380                    {
    55895381                        size_t index = 0;
    5590                         if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
     5382                        if (m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
    55915383                        {
    55925384                            r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    55935385
    55945386#if DEBUG_MEMC_XRAM_RSP
    5595                             if(m_debug)
     5387                            if (m_debug)
    55965388                                std::cout << "  <MEMC " << name() << " XRAM_RSP_IVT_LOCK>"
    55975389                                    << " Get acces to IVT, but line invalidation registered"
     
    56015393
    56025394                        }
    5603                         else if(m_ivt.is_full() and r_xram_rsp_victim_inval.read()) // IVT full
     5395                        else if (m_ivt.is_full() and r_xram_rsp_victim_inval.read()) // IVT full
    56045396                        {
    56055397                            r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    56065398
    56075399#if DEBUG_MEMC_XRAM_RSP
    5608                             if(m_debug)
     5400                            if (m_debug)
    56095401                                std::cout << "  <MEMC " << name() << " XRAM_RSP_IVT_LOCK>"
    56105402                                    << " Get acces to IVT, but inval required and IVT full" << std::endl;
     
    56165408
    56175409#if DEBUG_MEMC_XRAM_RSP
    5618                             if(m_debug)
     5410                            if (m_debug)
    56195411                                std::cout << "  <MEMC " << name() << " XRAM_RSP_IVT_LOCK>"
    56205412                                    << " Get acces to IVT / no pending inval request" << std::endl;
     
    56295421
    56305422#if DEBUG_MEMC_XRAM_RSP
    5631                     if(m_debug)
     5423                    if (m_debug)
    56325424                        std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_WAIT>"
    56335425                            << " Release all locks and retry" << std::endl;
     
    56805472                    DirectoryEntry entry;
    56815473
    5682                     if(inst_read and (r_xram_rsp_trt_buf.proc_read))
     5474                    if (inst_read and (r_xram_rsp_trt_buf.proc_read))
    56835475                    {
    56845476                        entry.state = ENTRY_SHARED;
     
    56945486                    entry.tag     = r_xram_rsp_trt_buf.nline / m_sets;
    56955487                    entry.ptr     = 0;
    5696                     if(cached_read and r_xram_rsp_trt_buf.proc_read)
     5488                    if (cached_read and r_xram_rsp_trt_buf.proc_read)
    56975489                    {
    56985490                        entry.owner.srcid   = r_xram_rsp_trt_buf.srcid;
     
    57105502                    r_xram_rsp_coherent = inst_read;
    57115503                    // request an invalidattion request in IVT for victim line
    5712                     if(r_xram_rsp_victim_inval.read())
     5504                    if (r_xram_rsp_victim_inval.read())
    57135505                    {
    57145506                        bool   broadcast    = r_xram_rsp_victim_is_cnt.read();
     
    57435535                   // }
    57445536#if DEBUG_MEMC_XRAM_RSP
    5745                     if(m_debug)
     5537                    if (m_debug)
    57465538                    {
    57475539                        std::cout << "  <MEMC " << name() << " XRAM_RSP_DIR_UPDT>"
     
    57545546                            << " / nline = " << r_xram_rsp_trt_buf.nline
    57555547                            << " / is_cnt = " << entry.is_cnt << std::endl;
    5756                         if(r_xram_rsp_victim_inval.read())
     5548                        if (r_xram_rsp_victim_inval.read())
    57575549                            std::cout << "                           Invalidation request for victim line "
    57585550                                << std::hex << r_xram_rsp_victim_nline.read()
     
    57635555                    // If the victim is not dirty (RWT: if it is not coherent, we can not know wether it is dirty or not), we don't need another XRAM  put transaction,
    57645556                    // and we can erase the TRT entry
    5765                     if( (not r_xram_rsp_victim_dirty.read()) or (r_xram_rsp_victim_state.read() == ENTRY_INVALID)) 
     5557                    if ((not r_xram_rsp_victim_dirty.read()) or (r_xram_rsp_victim_state.read() == ENTRY_INVALID)) 
    57665558                    {
    57675559                        m_trt.erase(r_xram_rsp_trt_index.read());
    57685560                    }
    57695561                    // Next state
    5770                     if(r_xram_rsp_victim_dirty.read())       r_xram_rsp_fsm = XRAM_RSP_TRT_DIRTY;
    5771                     else if(r_xram_rsp_trt_buf.proc_read)    r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
    5772                     else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
     5562                    if (r_xram_rsp_victim_dirty.read())       r_xram_rsp_fsm = XRAM_RSP_TRT_DIRTY;
     5563                    else if (r_xram_rsp_trt_buf.proc_read)    r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
     5564                    else if (r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
    57735565                    else                                     r_xram_rsp_fsm = XRAM_RSP_IDLE;
    57745566                    break;
     
    57775569            case XRAM_RSP_TRT_DIRTY:  // set the TRT entry (write to XRAM) if the victim is dirty or not coherent (RWT)
    57785570                {
    5779                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP)
     5571                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP)
    57805572                    {
    57815573                        std::vector<data_t> data_vector;
     
    57985590                                   data_vector);
    57995591#if DEBUG_MEMC_XRAM_RSP
    5800                         if(m_debug)
     5592                        if (m_debug)
    58015593                            std::cout << "  <MEMC " << name() << " XRAM_RSP_TRT_DIRTY>"
    58025594                                << " Set TRT entry for the put transaction"
     
    58045596#endif
    58055597
    5806                         //        if( not r_xram_rsp_victim_coherent )
     5598                        //        if (not r_xram_rsp_victim_coherent )
    58075599                        //            std::cout << "a victim coherent not sent trt index =" << r_xram_rsp_trt_index.read() << std::endl;
    5808                         if(r_xram_rsp_trt_buf.proc_read)         r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
    5809                         else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
     5600                        if (r_xram_rsp_trt_buf.proc_read)         r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
     5601                        else if (r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
    58105602                        else                                     r_xram_rsp_fsm = XRAM_RSP_WRITE_DIRTY;
    5811                         m_cpt_xram_rsp_fsm_n_trt_lock++;
    5812                     }
    5813 
    5814                     m_cpt_xram_rsp_fsm_trt_lock++;
    5815 
     5603                    }
    58165604                    break;
    58175605                }
     
    58195607            case XRAM_RSP_DIR_RSP:     // Request a response to TGT_RSP FSM
    58205608                {
    5821                     if( not r_xram_rsp_to_tgt_rsp_req.read())
     5609                    if (not r_xram_rsp_to_tgt_rsp_req.read())
    58225610                    {
    58235611                        r_xram_rsp_to_tgt_rsp_srcid = r_xram_rsp_trt_buf.srcid;
     
    58425630
    58435631
    5844                         if(r_xram_rsp_victim_inval)      r_xram_rsp_fsm = XRAM_RSP_INVAL;
    5845                         else if(r_xram_rsp_victim_dirty) r_xram_rsp_fsm = XRAM_RSP_WRITE_DIRTY;
     5632                        if (r_xram_rsp_victim_inval)      r_xram_rsp_fsm = XRAM_RSP_INVAL;
     5633                        else if (r_xram_rsp_victim_dirty) r_xram_rsp_fsm = XRAM_RSP_WRITE_DIRTY;
    58465634                        else                             r_xram_rsp_fsm = XRAM_RSP_IDLE;
    58475635
    58485636#if DEBUG_MEMC_XRAM_RSP
    5849                         if(m_debug)
     5637                        if (m_debug)
    58505638                            std::cout << "  <MEMC " << name() << " XRAM_RSP_DIR_RSP>"
    58515639                                << " Request the TGT_RSP FSM to return data:"
     
    58615649            case XRAM_RSP_INVAL:  // send invalidate request to CC_SEND FSM
    58625650                {
    5863                     if(!r_xram_rsp_to_cc_send_multi_req.read() and
     5651                    if (!r_xram_rsp_to_cc_send_multi_req.read() and
    58645652                            !r_xram_rsp_to_cc_send_brdcast_req.read())
    58655653                    {
     
    58775665                        r_xram_rsp_next_ptr                = r_xram_rsp_victim_ptr.read();
    58785666
    5879                         if(r_xram_rsp_victim_dirty.read() and (r_xram_rsp_victim_state.read() == ENTRY_SHARED)) 
     5667                        if (r_xram_rsp_victim_dirty.read() and (r_xram_rsp_victim_state.read() == ENTRY_SHARED)) 
    58805668                                                     r_xram_rsp_fsm = XRAM_RSP_WRITE_DIRTY;
    5881                         else if(not_last_multi_req)  r_xram_rsp_fsm = XRAM_RSP_HEAP_REQ;
     5669                        else if (not_last_multi_req)  r_xram_rsp_fsm = XRAM_RSP_HEAP_REQ;
    58825670                        else                         r_xram_rsp_fsm = XRAM_RSP_IDLE;
    58835671
    58845672                        // std::cout << "cleanup sent for trt index =" << r_xram_rsp_trt_index.read() << std::endl;
    58855673#if DEBUG_MEMC_XRAM_RSP
    5886                         if(m_debug)
     5674                        if (m_debug)
    58875675                            std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL>"
    58885676                                << " Send an inval request to CC_SEND FSM"
     
    58935681                    {
    58945682#if DEBUG_MEMC_XRAM_RSP
    5895                         if(m_debug)
     5683                        if (m_debug)
    58965684                            std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL>"
    58975685                                << " multi req = " << r_xram_rsp_to_cc_send_multi_req.read()
     
    59045692            case XRAM_RSP_WRITE_DIRTY:  // send a write request to IXR_CMD FSM
    59055693                {
    5906                     if ( not r_xram_rsp_to_ixr_cmd_req.read() )
    5907                     {
    5908                         if((r_xram_rsp_victim_state.read() == ENTRY_EXCLUSIVE) and (r_xram_rsp_victim_count.read() == 1))
     5694                    if (not r_xram_rsp_to_ixr_cmd_req.read() )
     5695                    {
     5696                        if ((r_xram_rsp_victim_state.read() == ENTRY_EXCLUSIVE) and (r_xram_rsp_victim_count.read() == 1))
    59095697                        {
    59105698                            std::cout << "can't send a trt req when the line state is exlusive" << std::endl;
     
    59145702                        r_xram_rsp_to_ixr_cmd_index = r_xram_rsp_trt_index.read();
    59155703
     5704                        // <Activity counters>
    59165705                        m_cpt_write_dirty++;
     5706                        // </Activity counters>
    59175707
    59185708                        bool multi_req = not r_xram_rsp_victim_is_cnt.read() and
     
    59205710                        bool not_last_multi_req = multi_req and (r_xram_rsp_victim_count.read() != 1);
    59215711
    5922                         if(not_last_multi_req)   r_xram_rsp_fsm = XRAM_RSP_HEAP_REQ;
     5712                        if (not_last_multi_req)   r_xram_rsp_fsm = XRAM_RSP_HEAP_REQ;
    59235713                        else                     r_xram_rsp_fsm = XRAM_RSP_IDLE;
    59245714
    59255715#if DEBUG_MEMC_XRAM_RSP
    5926                         if(m_debug)
     5716                        if (m_debug)
    59275717                            std::cout << "  <MEMC " << name() << " XRAM_RSP_WRITE_DIRTY>"
    59285718                                << " Send the put request to IXR_CMD FSM"
     
    59355725            case XRAM_RSP_HEAP_REQ:    // Get the lock to the HEAP
    59365726                {
    5937                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_XRAM_RSP)
     5727                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_XRAM_RSP)
    59385728                    {
    59395729                        r_xram_rsp_fsm = XRAM_RSP_HEAP_ERASE;
    5940                         m_cpt_xram_rsp_fsm_n_heap_lock++;
    59415730                    }
    59425731
    59435732#if DEBUG_MEMC_XRAM_RSP
    5944                     if(m_debug)
     5733                    if (m_debug)
    59455734                        std::cout << "  <MEMC " << name() << " XRAM_RSP_HEAP_REQ>"
    59465735                            << " Requesting HEAP lock" << std::endl;
    59475736#endif
    5948 
    5949                     m_cpt_xram_rsp_fsm_heap_lock++;
    5950 
    59515737                    break;
    59525738                }
     
    59545740            case XRAM_RSP_HEAP_ERASE: // erase the copies and send invalidations
    59555741                {
    5956                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_XRAM_RSP)
     5742                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_XRAM_RSP)
    59575743                    {
    59585744                        HeapEntry entry = m_heap.read(r_xram_rsp_next_ptr.read());
     
    59615747                        xram_rsp_to_cc_send_fifo_inst  = entry.owner.inst;
    59625748                        xram_rsp_to_cc_send_fifo_put   = true;
    5963                         if(m_xram_rsp_to_cc_send_inst_fifo.wok())
     5749                        if (m_xram_rsp_to_cc_send_inst_fifo.wok())
    59645750                        {
    59655751                            r_xram_rsp_next_ptr = entry.next;
    5966                             if(entry.next == r_xram_rsp_next_ptr.read())   // last copy
     5752                            if (entry.next == r_xram_rsp_next_ptr.read())   // last copy
    59675753                            {
    59685754                                r_xram_rsp_to_cc_send_multi_req = true;
     
    59805766
    59815767#if DEBUG_MEMC_XRAM_RSP
    5982                         if(m_debug)
     5768                        if (m_debug)
    59835769                            std::cout << "  <MEMC " << name() << " XRAM_RSP_HEAP_ERASE>"
    59845770                                << " Erase copy:"
     
    59945780            case XRAM_RSP_HEAP_LAST:  // last copy
    59955781                {
    5996                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_XRAM_RSP)
     5782                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_XRAM_RSP)
    59975783                    {
    59985784                        std::cout << "VCI_MEM_CACHE ERROR " << name() << " XRAM_RSP_HEAP_LAST"
     
    60055791                    last_entry.owner.srcid    = 0;
    60065792                    last_entry.owner.inst     = false;
    6007                     if(m_heap.is_full())
     5793                    if (m_heap.is_full())
    60085794                    {
    60095795                        last_entry.next     = r_xram_rsp_next_ptr.read();
     
    60215807
    60225808#if DEBUG_MEMC_XRAM_RSP
    6023                     if(m_debug)
     5809                    if (m_debug)
    60245810                        std::cout << "  <MEMC " << name() << " XRAM_RSP_HEAP_LAST>"
    60255811                            << " Heap housekeeping" << std::endl;
     
    60335819
    60345820                    // Next state
    6035                     if(r_xram_rsp_trt_buf.proc_read) r_xram_rsp_fsm = XRAM_RSP_ERROR_RSP;
     5821                    if (r_xram_rsp_trt_buf.proc_read) r_xram_rsp_fsm = XRAM_RSP_ERROR_RSP;
    60365822                    else                             r_xram_rsp_fsm = XRAM_RSP_IDLE;
    60375823
    60385824#if DEBUG_MEMC_XRAM_RSP
    6039                     if(m_debug)
     5825                    if (m_debug)
    60405826                        std::cout << "  <MEMC " << name() << " XRAM_RSP_ERROR_ERASE>"
    60415827                            << " Error reported by XRAM / erase the TRT entry" << std::endl;
     
    60465832            case XRAM_RSP_ERROR_RSP:     // Request an error response to TGT_RSP FSM
    60475833                {
    6048                     if(!r_xram_rsp_to_tgt_rsp_req.read())
     5834                    if (!r_xram_rsp_to_tgt_rsp_req.read())
    60495835                    {
    60505836                        r_xram_rsp_to_tgt_rsp_srcid  = r_xram_rsp_trt_buf.srcid;
     
    60635849
    60645850#if DEBUG_MEMC_XRAM_RSP
    6065                         if(m_debug)
     5851                        if (m_debug)
    60665852                            std::cout << "  <MEMC " << name()
    60675853                                << " XRAM_RSP_ERROR_RSP> Request a response error to TGT_RSP FSM:"
     
    60855871            case CLEANUP_IDLE:     // Get first DSPIN flit of the CLEANUP command
    60865872                {
    6087                     if(not m_cc_receive_to_cleanup_fifo.rok()) break;
     5873                    if (not m_cc_receive_to_cleanup_fifo.rok()) break;
    60885874
    60895875                    uint64_t flit = m_cc_receive_to_cleanup_fifo.read();
    60905876
    60915877                    uint32_t srcid =
    6092                         DspinDhccpParam::dspin_get(
     5878                        DspinHmesiParam::dspin_get(
    60935879                                flit,
    6094                                 DspinDhccpParam::CLEANUP_SRCID);
     5880                                DspinHmesiParam::CLEANUP_SRCID);
    60955881
    60965882                    uint8_t type =
    6097                         DspinDhccpParam::dspin_get(
     5883                        DspinHmesiParam::dspin_get(
    60985884                                flit,
    6099                                 DspinDhccpParam::P2M_TYPE);
     5885                                DspinHmesiParam::P2M_TYPE);
    61005886
    61015887                    r_cleanup_way_index =
    6102                         DspinDhccpParam::dspin_get(
     5888                        DspinHmesiParam::dspin_get(
    61035889                                flit,
    6104                                 DspinDhccpParam::CLEANUP_WAY_INDEX);
     5890                                DspinHmesiParam::CLEANUP_WAY_INDEX);
    61055891
    61065892                    r_cleanup_nline =
    6107                         DspinDhccpParam::dspin_get(
     5893                        DspinHmesiParam::dspin_get(
    61085894                                flit,
    6109                                 DspinDhccpParam::CLEANUP_NLINE_MSB) << 32;
    6110 
    6111                     r_cleanup_inst  = (type == DspinDhccpParam::TYPE_CLEANUP_INST);
     5895                                DspinHmesiParam::CLEANUP_NLINE_MSB) << 32;
     5896
     5897                    r_cleanup_inst  = (type == DspinHmesiParam::TYPE_CLEANUP_INST);
    61125898                    r_cleanup_srcid = srcid;
    61135899                    r_cleanup_ncc =
    6114                         DspinDhccpParam::dspin_get(
     5900                        DspinHmesiParam::dspin_get(
    61155901                                flit,
    6116                                 DspinDhccpParam::DATA_NO_SHARED);
     5902                                DspinHmesiParam::DATA_NO_SHARED);
    61175903
    61185904                    assert( (srcid < m_initiators) and
    61195905                            "MEMC ERROR in CLEANUP_IDLE state : illegal SRCID value");
    61205906
    6121                     // <Activity Counters>
    6122                     if (is_local_req(srcid)) {
    6123                         m_cpt_cleanup_local++;
    6124                     }
    6125                     else {
    6126                         m_cpt_cleanup_remote++;
    6127                         m_cpt_cleanup_cost += req_distance(srcid);
    6128                     }
    6129                     // </Activity Counters>
    61305907                    cc_receive_to_cleanup_fifo_get = true;
    61315908                    r_cleanup_fsm                  = CLEANUP_GET_NLINE;
    61325909
    61335910#if DEBUG_MEMC_CLEANUP
    6134                     if(m_debug)
     5911                    if (m_debug)
    61355912                    {
    61365913                        std::cout
     
    61385915                            << " CLEANUP_IDLE> Cleanup request:" << std::hex
    61395916                            << " / owner_id = "   << srcid
    6140                             << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST)
    6141                             << " / ncc = " << DspinDhccpParam::dspin_get(
     5917                            << " / owner_ins = "  << (type == DspinHmesiParam::TYPE_CLEANUP_INST)
     5918                            << " / ncc = " << DspinHmesiParam::dspin_get(
    61425919                                    flit,
    6143                                     DspinDhccpParam::DATA_NO_SHARED)
     5920                                    DspinHmesiParam::DATA_NO_SHARED)
    61445921                            << std::endl;
    61455922                    }
     
    61515928            case CLEANUP_GET_NLINE:  // GET second DSPIN flit of the cleanup command
    61525929                {
    6153                     if(not m_cc_receive_to_cleanup_fifo.rok()) break;
     5930                    if (not m_cc_receive_to_cleanup_fifo.rok()) break;
    61545931
    61555932                    uint64_t flit = m_cc_receive_to_cleanup_fifo.read();
     5933                    uint32_t srcid = r_cleanup_srcid.read();
    61565934
    61575935                    addr_t nline = r_cleanup_nline.read() |
    6158                         DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB);
     5936                        DspinHmesiParam::dspin_get(flit, DspinHmesiParam::CLEANUP_NLINE_LSB);
    61595937
    61605938                    //A MODIFIER POUR DIRTY //
    61615939                    bool eop =
    6162                         DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     5940                        DspinHmesiParam::dspin_get(flit, DspinHmesiParam::P2M_EOP) == 0x1;
    61635941                    if (! eop)
    61645942                    {
     
    61665944                        r_cleanup_data_index    = 0;
    61675945                        r_cleanup_contains_data = true;
    6168                         m_cpt_cleanup_with_data ++;
     5946                        // <Activity Counters>
     5947                        if (is_local_req(srcid)) {
     5948                            m_cpt_cleanup_local++;
     5949                            m_cpt_cleanup_data_local++;
     5950                        }
     5951                        else {
     5952                            m_cpt_cleanup_remote++;
     5953                            m_cpt_cleanup_data_remote++;
     5954                        }
     5955                        // 2 + m_words flits for cleanup with data
     5956                        m_cpt_cleanup_cost += (m_words + 2) * req_distance(srcid);
     5957                        m_cpt_cleanup_data_cost += (m_words + 2)  * req_distance(srcid);
     5958                        // </Activity Counters>
    61695959                    }
    61705960                    else
    61715961                    {
    6172                        /*// if( (r_write_to_cleanup_req.read() == true) and (r_write_to_cleanup_nline.read() == nline ))
    6173                         {
    6174                             std::cout << "receive write nline without data" << std::hex << nline << std::endl;
    6175 
    6176                         }*/
    61775962                        r_cleanup_contains_data = false;
    61785963                        r_cleanup_fsm = CLEANUP_DIR_REQ;
     5964                        // <Activity Counters>
     5965                        if (is_local_req(srcid)) {
     5966                            m_cpt_cleanup_local++;
     5967                        }
     5968                        else {
     5969                            m_cpt_cleanup_remote++;
     5970                        }
     5971                        // 2 flits for cleanup without data
     5972                        m_cpt_cleanup_cost += 2 * req_distance(srcid);
     5973                        // </Activity Counters>
    61795974                    }
    61805975                    cc_receive_to_cleanup_fifo_get = true;
    6181                     r_cleanup_nline                = nline;
     5976                    r_cleanup_nline = nline;
    61825977                   
    61835978#if DEBUG_MEMC_CLEANUP
    6184                     if(m_debug)
     5979                    if (m_debug)
    61855980                    {
    61865981                        std::cout
     
    62035998
    62045999                        uint32_t data =
    6205                             DspinDhccpParam::dspin_get (flit, DspinDhccpParam::CLEANUP_DATA_UPDT);
    6206 
    6207                         if( (r_write_to_cleanup_req.read() == true) and (r_write_to_cleanup_nline.read() == r_cleanup_nline.read()) )
     6000                            DspinHmesiParam::dspin_get (flit, DspinHmesiParam::CLEANUP_DATA_UPDT);
     6001
     6002                        if ((r_write_to_cleanup_req.read() == true) and (r_write_to_cleanup_nline.read() == r_cleanup_nline.read()) )
    62086003                        {
    62096004                            data_t mask = 0;
    6210                             if(r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x1) mask = mask | 0x000000FF;
    6211                             if(r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x2) mask = mask | 0x0000FF00;
    6212                             if(r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x4) mask = mask | 0x00FF0000;
    6213                             if(r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x8) mask = mask | 0xFF000000;
     6005                            if (r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x1) mask = mask | 0x000000FF;
     6006                            if (r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x2) mask = mask | 0x0000FF00;
     6007                            if (r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x4) mask = mask | 0x00FF0000;
     6008                            if (r_write_to_cleanup_be[r_cleanup_data_index.read()].read() & 0x8) mask = mask | 0xFF000000;
    62146009       
    62156010                            // complete only if mask is not null (for energy consumption)
     
    62316026                        }
    62326027#if DEBUG_MEMC_CLEANUP
    6233                         if(m_debug)
     6028                        if (m_debug)
    62346029                        {
    62356030                            std::cout
     
    62476042            case CLEANUP_DIR_REQ:   // Get the lock to the directory
    62486043                {
    6249                     m_cpt_cleanup_fsm_dir_lock++;
    6250                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP) break;
     6044                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP) break;
    62516045
    62526046                    r_cleanup_fsm = CLEANUP_DIR_LOCK;
     
    62546048
    62556049#if DEBUG_MEMC_CLEANUP
    6256                     if(m_debug)
     6050                    if (m_debug)
    62576051                        std::cout << "  <MEMC " << name() << " CLEANUP_DIR_REQ> Requesting DIR lock" << std::endl;
    62586052#endif
    6259 
    6260                     m_cpt_cleanup_fsm_n_dir_lock++;
    6261 
    62626053                    break;
    62636054                }
     
    62676058                {
    62686059                    // test directory status
    6269                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP)
     6060                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP)
    62706061                    {
    62716062                        std::cout
     
    62926083                    r_cleanup_state        = entry.state;
    62936084
    6294                     if(entry.state == ENTRY_LOCKED)     
     6085                    if (entry.state == ENTRY_LOCKED)     
    62956086                    {
    62966087                        assert(
     
    63026093                        r_cleanup_fsm = CLEANUP_LOCKED_IVT_LOCK;
    63036094                    }
    6304                     else if(entry.state == ENTRY_INVALID)
     6095                    else if (entry.state == ENTRY_INVALID)
    63056096                    {
    63066097                        r_cleanup_fsm = CLEANUP_MISS_IVT_LOCK;
     
    63136104                                "In CLEANUP_DIR_LOCK, CLEANUP command on a valid entry "
    63146105                                "with no copies");
    6315                         if((entry.state == ENTRY_SHARED) and (entry.is_cnt == true))
     6106                        if ((entry.state == ENTRY_SHARED) and (entry.is_cnt == true))
    63166107                        {
    63176108                            r_cleanup_fsm = CLEANUP_DIR_WRITE;
    63186109                        }
    6319                         else if((entry.state == ENTRY_EXCLUSIVE) or (entry.count == 1))
     6110                        else if ((entry.state == ENTRY_EXCLUSIVE) or (entry.count == 1))
    63206111                        {
    63216112                            r_cleanup_fsm = CLEANUP_DIR_WRITE;
     
    63286119
    63296120#if DEBUG_MEMC_CLEANUP
    6330                     if(m_debug)
     6121                    if (m_debug)
    63316122                    {
    63326123                        std::cout
     
    63536144                {
    63546145                    // Update the directory entry without heap access
    6355                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP)
     6146                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP)
    63566147                    {
    63576148                        std::cout
     
    63706161                    bool   match       = match_srcid and match_inst;
    63716162
    6372                     if( (r_cleanup_state.read() == ENTRY_EXCLUSIVE) and not match )
     6163                    if ((r_cleanup_state.read() == ENTRY_EXCLUSIVE) and not match )
    63736164                    {
    63746165                        std::cout
     
    63926183                    entry.state          = r_cleanup_state.read();
    63936184
    6394                     if( entry.count == 0)
     6185                    if (entry.count == 0)
    63956186                    {
    63966187                        entry.is_cnt = 0;
     
    64166207
    64176208#if DEBUG_MEMC_CLEANUP
    6418                     if(m_debug)
     6209                    if (m_debug)
    64196210                    {
    64206211                        std::cout
     
    64386229                {
    64396230                    //Search for a matching inval in the ivt (there must be one) and check if there is a pending read or cas.
    6440 
    6441                     m_cpt_cleanup_fsm_ivt_lock++;
    6442                     if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CLEANUP)
     6231                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_CLEANUP)
    64436232                    {
    64446233                        size_t index = 0;
     
    64686257                        r_cleanup_locked_is_read    = m_ivt.is_read(index);
    64696258
    6470                         if( m_ivt.is_update(index) and not m_ivt.is_changed(index))
     6259                        if (m_ivt.is_update(index) and not m_ivt.is_changed(index))
    64716260                        {
    64726261                            r_cleanup_fsm = CLEANUP_LOCKED_IVT_CLEAR;
     
    64936282                    m_ivt.decrement(r_cleanup_locked_index.read(), count);
    64946283
    6495                     if(count == 0)
     6284                    if (count == 0)
    64966285                    {
    64976286                        r_cleanup_fsm = CLEANUP_LOCKED_IVT_CLEAR;
     
    65046293
    65056294#if DEBUG_MEMC_CLEANUP
    6506                     if(m_debug)
     6295                    if (m_debug)
    65076296                        std::cout << "  <MEMC " << name() << " CLEANUP_LOCKED_IVT_DECREMENT>"
    65086297                            << " Decrement response counter in IVT:"
     
    65346323                    entry.ptr           = r_cleanup_ptr.read();
    65356324                   
    6536                     if( not r_cleanup_contains_data.read() )
    6537                     {
    6538                         if(r_write_to_cleanup_req.read() and r_write_to_cleanup_nline.read() == r_cleanup_nline.read())
     6325                    if (not r_cleanup_contains_data.read() )
     6326                    {
     6327                        if (r_write_to_cleanup_req.read() and r_write_to_cleanup_nline.read() == r_cleanup_nline.read())
    65396328                        //update the line with the data saved in write_to_cleanup_data table if the cleanup without data
    65406329                        {
     
    65566345                        }
    65576346
    6558                         if((r_cleanup_locked_pktid.read() & 0x7) != TYPE_SC)
     6347                        if ((r_cleanup_locked_pktid.read() & 0x7) != TYPE_SC)
    65596348                        {
    65606349                           // addr_t min = r_cleanup_nline.read()*m_words*4 ;
     
    65646353                    }
    65656354
    6566                     if(r_cleanup_locked_is_updt.read() and not r_cleanup_locked_is_changed.read()) //cleanup req cross with multi ack rsp. here, just decrements the count and remains the state.
     6355                    if (r_cleanup_locked_is_updt.read() and not r_cleanup_locked_is_changed.read()) //cleanup req cross with multi ack rsp. here, just decrements the count and remains the state.
    65676356                    {
    65686357                        assert(r_cleanup_count.read() == 1 && " only one copy when cleanup fsm receives a req for is_updt command");
     
    65736362                        r_cleanup_fsm       = CLEANUP_SEND_CLACK;
    65746363                    }
    6575                     else if(r_cleanup_locked_is_updt.read() and r_cleanup_locked_is_changed.read())
     6364                    else if (r_cleanup_locked_is_updt.read() and r_cleanup_locked_is_changed.read())
    65766365                    {
    65776366                        entry.state = ENTRY_SHARED;
    6578                         if(match_ll)
     6367                        if (match_ll)
    65796368                        {
    65806369                            entry.count       = 0;
     
    65876376                        }
    65886377
    6589                         if((r_cleanup_locked_pktid.read() & 0x7) == TYPE_READ_INS_MISS)
     6378                        if ((r_cleanup_locked_pktid.read() & 0x7) == TYPE_READ_INS_MISS)
    65906379                        {
    65916380                            entry.owner.inst = true;
     
    66016390                    else // cas, getm, one copy updated in dir
    66026391                    {
    6603                         if(r_cleanup_locked_is_read.read())
     6392                        if (r_cleanup_locked_is_read.read())
    66046393                        {
    66056394                            entry.state         = ENTRY_EXCLUSIVE;
     
    66386427            case CLEANUP_LOCKED_RSP:
    66396428                {
    6640                     if(r_cleanup_to_tgt_rsp_req.read()) break;
     6429                    if (r_cleanup_to_tgt_rsp_req.read()) break;
    66416430
    66426431                    r_cleanup_to_tgt_rsp_req     = true;
     
    66456434                    r_cleanup_to_tgt_rsp_nline   = r_cleanup_nline.read();
    66466435                   
    6647                     if(r_cleanup_locked_is_changed.read() and r_cleanup_locked_is_updt.read())
     6436                    if (r_cleanup_locked_is_changed.read() and r_cleanup_locked_is_updt.read())
    66486437                    {
    66496438                        r_cleanup_to_tgt_rsp_pktid   = r_cleanup_locked_pktid.read(); // rsp for is_updt in shared state
     
    66556444                    }
    66566445
    6657                     if(r_read_to_multi_ack_req.read() and (r_read_to_multi_ack_nline.read() == r_cleanup_nline.read()) and // rsp for LL or pheriph
     6446                    if (r_read_to_multi_ack_req.read() and (r_read_to_multi_ack_nline.read() == r_cleanup_nline.read()) and // rsp for LL or pheriph
    66586447                      (r_cleanup_locked_is_changed.read() and r_cleanup_locked_is_updt.read()))
    66596448                    {
     
    66636452                        r_read_to_multi_ack_req           = false;
    66646453                    }
    6665                     else if(r_read_to_cleanup_req.read() and (r_read_to_cleanup_nline.read() == r_cleanup_nline.read())) // rsp for LL or pheriph
     6454                    else if (r_read_to_cleanup_req.read() and (r_read_to_cleanup_nline.read() == r_cleanup_nline.read())) // rsp for LL or pheriph
    66666455                    {
    66676456                        r_cleanup_to_tgt_rsp_ll_key     = r_read_to_cleanup_ll_key.read();
     
    66776466                    }
    66786467
    6679                     if(r_write_to_cleanup_req.read() and r_write_to_cleanup_nline.read() == r_cleanup_nline.read())
     6468                    if (r_write_to_cleanup_req.read() and r_write_to_cleanup_nline.read() == r_cleanup_nline.read())
    66806469                        r_write_to_cleanup_req = false;
    66816470
     
    67086497                {
    67096498                    // get the lock to the HEAP directory
    6710                     m_cpt_cleanup_fsm_heap_lock ++;
    6711                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_CLEANUP) break;
     6499                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_CLEANUP) break;
    67126500
    67136501                    r_cleanup_fsm = CLEANUP_HEAP_LOCK;
    67146502
    67156503#if DEBUG_MEMC_CLEANUP
    6716                     if(m_debug)
     6504                    if (m_debug)
    67176505                    {
    67186506                        std::cout
     
    67226510                    }
    67236511#endif
    6724                     m_cpt_cleanup_fsm_n_heap_lock++;
    67256512                    break;
    67266513                }
     
    67736560                    // it must be replaced by the first copy registered in
    67746561                    // the heap. The corresponding entry must be freed
    6775                     if(match_dir)
     6562                    if (match_dir)
    67766563                    {
    67776564                        dir_entry.ptr            = heap_entry.next;
     
    67856572                    // It must be freed and the copy registered in directory
    67866573                    // must point to the next copy in heap
    6787                     else if(match_heap)
     6574                    else if (match_heap)
    67886575                    {
    67896576                        dir_entry.ptr            = heap_entry.next;
     
    68086595
    68096596#if DEBUG_MEMC_CLEANUP
    6810                     if(m_debug)
     6597                    if (m_debug)
    68116598                    {
    68126599                        std::cout
     
    68456632
    68466633                    // the matching copy must be removed
    6847                     if(match_heap)
     6634                    if (match_heap)
    68486635                    {
    68496636                        // re-use ressources
     
    68626649
    68636650#if DEBUG_MEMC_CLEANUP
    6864                     if(m_debug)
    6865                     {
    6866                         if(not match_heap)
     6651                    if (m_debug)
     6652                    {
     6653                        if (not match_heap)
    68676654                        {
    68686655                            std::cout
     
    69036690
    69046691                    // this is the last entry of the list of copies
    6905                     if(last)
     6692                    if (last)
    69066693                    {
    69076694                        heap_entry.next = r_cleanup_prev_ptr.read();
     
    69186705
    69196706#if DEBUG_MEMC_CLEANUP
    6920                     if(m_debug)
     6707                    if (m_debug)
    69216708                        std::cout << "  <MEMC " << name() << " CLEANUP_HEAP_SEARCH>"
    69226709                            << " Remove the copy in the linked list" << std::endl;
     
    69346721                    heap_entry.owner.inst     = false;
    69356722
    6936                     if(m_heap.is_full())
     6723                    if (m_heap.is_full())
    69376724                    {
    69386725                        heap_entry.next = r_cleanup_next_ptr.read();
     
    69506737
    69516738#if DEBUG_MEMC_CLEANUP
    6952                     if(m_debug)
     6739                    if (m_debug)
    69536740                        std::cout << "  <MEMC " << name() << " CLEANUP_HEAP_FREE>"
    69546741                            << " Update the list of free entries" << std::endl;
     
    69606747                // invalidate transaction matching the cleanup
    69616748                {
    6962                     m_cpt_cleanup_fsm_ivt_lock++;
    6963                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
     6749                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    69646750
    69656751                    size_t index = 0;
    69666752                    bool   match_inval;
    69676753
    6968                     m_cpt_cleanup_fsm_n_ivt_lock++;
    6969 
    69706754                    match_inval = m_ivt.search_inval(r_cleanup_nline.read(), index);
    6971                     if ( not match_inval )     // no pending inval
     6755                    if (not match_inval )     // no pending inval
    69726756                    {
    69736757                        r_cleanup_fsm = CLEANUP_SEND_CLACK;
    69746758
    69756759#if DEBUG_MEMC_CLEANUP
    6976                         if(m_debug)
     6760                        if (m_debug)
    69776761                            std::cout << "  <MEMC " << name()
    69786762                                << " CLEANUP_MISS_IVT_LOCK> Unexpected cleanup"
     
    69826766                                << std::endl;
    69836767#endif
    6984                         m_cpt_cleanup_fsm_n_ivt_lock++;
    69856768                    }
    69866769                    else
     
    69956778                        r_cleanup_fsm               = CLEANUP_MISS_IVT_DECREMENT;
    69966779#if DEBUG_MEMC_CLEANUP
    6997                         if(m_debug)
     6780                        if (m_debug)
    69986781                            std::cout << "  <MEMC " << name()
    69996782                                << " CLEANUP_MISS_IVT_LOCK> Cleanup matching pending"
     
    70156798                    m_ivt.decrement(r_cleanup_miss_index.read(), count);
    70166799
    7017                     if(count == 0)   // multi inval transaction completed
     6800                    if (count == 0)   // multi inval transaction completed
    70186801                    {
    70196802                        r_cleanup_fsm = CLEANUP_MISS_IVT_CLEAR;
     
    70256808
    70266809#if DEBUG_MEMC_CLEANUP
    7027                     if(m_debug)
     6810                    if (m_debug)
    70286811                        std::cout << "  <MEMC " << name() << " CLEANUP_MISS_IVT_DECREMENT>"
    70296812                            << " Decrement response counter in IVT:"
     
    70416824                    m_ivt.clear(r_cleanup_miss_index.read());
    70426825
    7043                     if ( r_cleanup_miss_need_ack.read() )
     6826                    if (r_cleanup_miss_need_ack.read() )
    70446827                    {
    70456828                        assert( (r_config_rsp_lines.read() > 0) and
     
    70546837                        r_cleanup_fsm = CLEANUP_MISS_RSP;
    70556838                    }
    7056                     else if ( r_cleanup_ncc.read() )
     6839                    else if (r_cleanup_ncc.read() )
    70576840                    {
    70586841                        r_cleanup_fsm = CLEANUP_MISS_IXR_REQ;
     
    70646847
    70656848#if DEBUG_MEMC_CLEANUP
    7066                     if(m_debug)
     6849                    if (m_debug)
    70676850                        std::cout << "  <MEMC "      << name()
    70686851                            << " CLEANUP_MISS_IVT_CLEAR> Clear entry in IVT:"
     
    70756858                // wait if pending request to the TGT_RSP FSM
    70766859                {
    7077                     if(r_cleanup_to_tgt_rsp_req.read()) break;
     6860                    if (r_cleanup_to_tgt_rsp_req.read()) break;
    70786861
    70796862                    // no pending request
     
    70846867                    r_cleanup_to_tgt_rsp_type    = true;
    70856868
    7086                     if ( r_cleanup_ncc.read() )
     6869                    if (r_cleanup_ncc.read() )
    70876870                    {
    70886871                        r_cleanup_fsm = CLEANUP_MISS_IXR_REQ;
     
    70946877
    70956878#if DEBUG_MEMC_CLEANUP
    7096                     if(m_debug)
     6879                    if (m_debug)
    70976880                        std::cout << "  <MEMC " << name() << " CLEANUP_MISS_RSP>"
    70986881                            << " Send a response to a previous write request: "
     
    71096892                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_CLEANUP)
    71106893                    {
    7111                         if( not r_cleanup_to_ixr_cmd_req.read())
     6894                        if (not r_cleanup_to_ixr_cmd_req.read())
    71126895                        {
    71136896                            size_t index = 0;
     
    71476930                            r_cleanup_fsm               = CLEANUP_SEND_CLACK;
    71486931#if DEBUG_MEMC_CLEANUP
    7149                             if(m_debug)
     6932                            if (m_debug)
    71506933                            {
    71516934                                std::cout
     
    71616944                            r_cleanup_fsm = CLEANUP_WAIT;
    71626945#if DEBUG_MEMC_CLEANUP
    7163                             if(m_debug)
     6946                            if (m_debug)
    71646947                            {
    71656948                                std::cout
     
    71866969                // on the coherence CLACK network.
    71876970                {
    7188                     if(not p_dspin_clack.read) break;
     6971                    if (not p_dspin_clack.read) break;
    71896972
    71906973                    r_cleanup_fsm = CLEANUP_IDLE;
    71916974
    71926975#if DEBUG_MEMC_CLEANUP
    7193                     if(m_debug)
     6976                    if (m_debug)
    71946977                        std::cout << "  <MEMC " << name()
    71956978                            << " CLEANUP_SEND_CLACK> Send the response to a cleanup request:"
     
    72337016            case CAS_IDLE:     // fill the local rdata buffers
    72347017                {
    7235                     if(m_cmd_cas_addr_fifo.rok())
     7018                    if (m_cmd_cas_addr_fifo.rok())
    72367019                    {
    72377020
    72387021#if DEBUG_MEMC_CAS
    7239                         if(m_debug)
     7022                        if (m_debug)
    72407023                        {
    72417024                            std::cout << "  <MEMC " << name() << " CAS_IDLE> CAS command: " << std::hex
     
    72477030                        }
    72487031#endif
    7249                         if(m_cmd_cas_eop_fifo.read())
     7032                        if (m_cmd_cas_eop_fifo.read())
    72507033                        {
    72517034                            r_cas_fsm = CAS_DIR_REQ;
     
    72567039                        }
    72577040                        // We fill the two buffers
    7258                         if(r_cas_cpt.read() < 2)    // 32 bits access
     7041                        if (r_cas_cpt.read() < 2)    // 32 bits access
    72597042                            r_cas_rdata[r_cas_cpt.read()] = m_cmd_cas_wdata_fifo.read();
    72607043
    7261                         if((r_cas_cpt.read() == 1) and m_cmd_cas_eop_fifo.read())
     7044                        if ((r_cas_cpt.read() == 1) and m_cmd_cas_eop_fifo.read())
    72627045                            r_cas_wdata = m_cmd_cas_wdata_fifo.read();
    72637046
     
    72657048                                "MEMC ERROR in CAS_IDLE state: illegal CAS command");
    72667049
    7267                         if(r_cas_cpt.read() ==2)
     7050                        if (r_cas_cpt.read() ==2)
    72687051                            r_cas_wdata = m_cmd_cas_wdata_fifo.read();
    72697052
     
    72767059            case CAS_DIR_REQ:
    72777060                {
    7278                     if(r_alloc_dir_fsm.read() == ALLOC_DIR_CAS)
     7061                    if (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS)
    72797062                    {
    72807063                        r_cas_fsm = CAS_DIR_LOCK;
    7281                         m_cpt_cas_fsm_n_dir_lock++;
    72827064                    }
    72837065
    72847066#if DEBUG_MEMC_CAS
    7285                     if(m_debug)
     7067                    if (m_debug)
    72867068                    {
    72877069                        std::cout
     
    72907072                    }
    72917073#endif
    7292 
    7293                     m_cpt_cas_fsm_dir_lock++;
    7294 
    72957074                    break;
    72967075                }
     
    73157094                    r_cas_count      = entry.count;
    73167095                   
    7317                     if(entry.state == ENTRY_LOCKED) 
     7096                    if (entry.state == ENTRY_LOCKED) 
    73187097                    {
    73197098                        r_cas_fsm = CAS_WAIT;
    7320                         m_cpt_cas_locked_rb ++;
    7321                     }
    7322                     else if(entry.state == ENTRY_INVALID) 
     7099                    }
     7100                    else if (entry.state == ENTRY_INVALID) 
    73237101                    {
    73247102                        r_cas_fsm = CAS_MISS_TRT_LOCK;
     
    73297107                    }
    73307108#if DEBUG_MEMC_CAS
    7331                     if(m_debug)
     7109                    if (m_debug)
    73327110                    {
    73337111                        std::cout << "  <MEMC " << name() << " CAS_DIR_LOCK> Directory acces"
     
    73677145
    73687146#if DEBUG_MEMC_CAS
    7369                     if(m_debug)
     7147                    if (m_debug)
    73707148                        std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_READ> Read data from "
    73717149                            << " cache and store it in buffer" << std::endl;
     
    73817159                    bool ok = (r_cas_rdata[0].read() == r_cas_data[word].read());
    73827160
    7383                     if(r_cas_cpt.read() == 4)     // 64 bits CAS
     7161                    if (r_cas_cpt.read() == 4)     // 64 bits CAS
    73847162                        ok &= (r_cas_rdata[1] == r_cas_data[word+1]);
    73857163
     
    73897167
    73907168                    // cas success
    7391                     if(ok and not forced_fail)
     7169                    if (ok and not forced_fail)
    73927170                    {
    73937171                        r_cas_fsm = CAS_DIR_HIT_WRITE;
     
    74007178
    74017179#if DEBUG_MEMC_CAS
    7402                     if(m_debug)
     7180                    if (m_debug)
    74037181                        std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_COMPARE> Compare the old"
    74047182                            << " and the new data"
     
    74207198
    74217199                    // test coherence request
    7422                     if(r_cas_count.read())   // replicated line
    7423                     {
    7424                         if(r_cas_count.read() == 1 and r_cas_state.read() == ENTRY_SHARED and r_cas_copy.read() == m_cmd_cas_srcid_fifo.read())
     7200                    if (r_cas_count.read())   // replicated line
     7201                    {
     7202                        if (r_cas_count.read() == 1 and r_cas_state.read() == ENTRY_SHARED and r_cas_copy.read() == m_cmd_cas_srcid_fifo.read())
    74257203                        {
    74267204                            DirectoryEntry entry;
     
    74427220                            // cache update
    74437221                            m_cache_data.write(way, set, word, r_cas_wdata.read());
    7444                             if(r_cas_cpt.read() == 4)
     7222                            if (r_cas_cpt.read() == 4)
    74457223                                m_cache_data.write(way, set, word+1, m_cmd_cas_wdata_fifo.read());
    74467224
     
    74527230                            r_cas_fsm = CAS_INVAL_IVT_LOCK;       // multi invalidate required
    74537231#if DEBUG_MEMC_CAS
    7454                             if(m_debug)
     7232                            if (m_debug)
    74557233                                std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE>"
    74567234                                    << " Multi Inval required"
     
    74677245                        // cache update
    74687246                        m_cache_data.write(way, set, word, r_cas_wdata.read());
    7469                         if(r_cas_cpt.read() == 4)
     7247                        if (r_cas_cpt.read() == 4)
    74707248                            m_cache_data.write(way, set, word+1, m_cmd_cas_wdata_fifo.read());
    74717249
     
    74737251
    74747252#if DEBUG_MEMC_CAS
    7475                         if(m_debug)
     7253                        if (m_debug)
    74767254                            std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE> Update cache:"
    74777255                                << " way = " << std::dec << way
     
    74907268                // releases locks to retry later if ivt full
    74917269                {
    7492                     if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS  and
     7270                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS  and
    74937271                        not r_cas_to_cc_send_multi_req.read()   and
    74947272                        not r_cas_to_cc_send_brdcast_req.read() and
     
    75137291                                        false,   // is a command write
    75147292                                        index);
    7515                         if(wok)   // coherence transaction registered in ivt
     7293                        if (wok)   // coherence transaction registered in ivt
    75167294                        {
    75177295                            // cache update
     
    75387316                            m_cache_data.write(way, set, word, r_cas_wdata.read());
    75397317
    7540                             if(r_cas_cpt.read() == 4)
     7318                            if (r_cas_cpt.read() == 4)
    75417319                                m_cache_data.write(way, set, word+1, m_cmd_cas_wdata_fifo.read());
    75427320
    7543                             if(r_cas_is_cnt.read())
    7544                                 m_cpt_cas_broadcast ++;
    7545                             else
    7546                                 m_cpt_cas_minval ++;
    7547 
    75487321                            //r_cas_ivt_index = index;
    7549                             if((r_cas_count.read() != 1) and not r_cas_is_cnt.read())
     7322                            if ((r_cas_count.read() != 1) and not r_cas_is_cnt.read())
    75507323                            {
    75517324                                r_cas_fsm = CAS_MULTI_INVAL_HEAP_LOCK;
     
    75557328                                assert(not r_cas_copy_inst.read() && "cas fsm: cas has a copy inst");
    75567329
    7557                                 if(not r_cas_is_cnt.read())
     7330                                if (not r_cas_is_cnt.read())
    75587331                                {
    75597332                                    cas_to_cc_send_fifo_put       = true;
     
    75747347                            }
    75757348#if DEBUG_MEMC_CAS
    7576                         if(m_debug)
     7349                        if (m_debug)
    75777350                            std::cout << "  <MEMC " << name()
    75787351                                << " CAS_INVAL_IVT_LOCK> Line is locked"
     
    75977370
    75987371#if DEBUG_MEMC_CAS
    7599                     if(m_debug)
     7372                    if (m_debug)
    76007373                    {
    76017374                        std::cout << "  <MEMC " << name()
     
    76097382            case CAS_MULTI_INVAL_HEAP_LOCK:  // lock the heap
    76107383                {
    7611                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_CAS)
     7384                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_CAS)
    76127385                    {
    76137386
    76147387#if DEBUG_MEMC_CAS
    7615                         if(m_debug)
     7388                        if (m_debug)
    76167389                        {
    76177390                            std::cout << "  <MEMC " << name()
     
    76207393#endif
    76217394                        r_cas_fsm = CAS_MULTI_INVAL_REQ;
    7622                         m_cpt_cas_fsm_n_heap_lock++;
    7623                     }
    7624 
    7625                     m_cpt_cas_fsm_heap_lock++;
    7626 
     7395                    }
    76277396                    break;
    76287397                }
     
    76357404                    assert(not r_cas_copy_inst.read() && "cas fsm: cas has a copy inst");
    76367405
    7637                     if(not r_cas_to_cc_send_multi_req.read() and not r_cas_to_cc_send_brdcast_req.read())
     7406                    if (not r_cas_to_cc_send_multi_req.read() and not r_cas_to_cc_send_brdcast_req.read())
    76387407                    {
    76397408                        r_cas_next_ptr                = r_cas_ptr.read();
     
    76447413                        cas_to_cc_send_fifo_srcid     = r_cas_copy.read();
    76457414                        // We put the first copy in the fifo
    7646                         if(r_cas_count.read() == 1)  // one single copy
     7415                        if (r_cas_count.read() == 1)  // one single copy
    76477416                        {
    76487417                            assert( false && "it should be more than one copies in cas_multi_inval_req!!!!");
     
    76547423
    76557424#if DEBUG_MEMC_CAS
    7656                         if(m_debug)
     7425                        if (m_debug)
    76577426                        {
    76587427                            std::cout << "  <MEMC " << name() << " CAS_MULTI_INVAL_REQ> Send the first update request to CC_SEND FSM "
     
    76807449                    assert(not entry.owner.inst && "cas fsm: cas has a copy inst");
    76817450
    7682                     if(m_cas_to_cc_send_inst_fifo.wok())   // request accepted by CC_SEND FSM
     7451                    if (m_cas_to_cc_send_inst_fifo.wok())   // request accepted by CC_SEND FSM
    76837452                    {   
    76847453                        cas_to_cc_send_fifo_srcid    = entry.owner.srcid;
     
    76867455                        cas_to_cc_send_fifo_put      = true;
    76877456                        r_cas_next_ptr               = entry.next;
    7688                         if(entry.next == r_cas_next_ptr.read())    // last copy
     7457                        if (entry.next == r_cas_next_ptr.read())    // last copy
    76897458                        {
    76907459                            r_cas_to_cc_send_multi_req  = true;
     
    76937462                    }
    76947463#if DEBUG_MEMC_CAS
    7695                     if(m_debug)
     7464                    if (m_debug)
    76967465                    {
    76977466                        std::cout << "  <MEMC " << name() << " CAS_HEAP_NEXT> Send the next update request to CC_SEND FSM "
     
    77077476            case CAS_HEAP_LAST:  // last copy
    77087477                {
    7709                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_CAS)
     7478                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_CAS)
    77107479                    {
    77117480                        std::cout << "VCI_MEM_CACHE ERROR " << name() << " CAS_HEAP_LAST"
     
    77187487                    last_entry.owner.srcid    = 0;
    77197488                    last_entry.owner.inst     = false;
    7720                     if(m_heap.is_full())
     7489                    if (m_heap.is_full())
    77217490                    {
    77227491                        last_entry.next     = r_cas_next_ptr.read();
     
    77367505 
    77377506#if DEBUG_MEMC_XRAM_RSP
    7738                     if(m_debug)
     7507                    if (m_debug)
    77397508                        std::cout << "  <MEMC " << name() << " CAS_HEAP_LAST>"
    77407509                            << " Heap housekeeping" << std::endl;
     
    77457514            case CAS_RSP_FAIL:  // request TGT_RSP FSM to send a failure response
    77467515                {
    7747                     if( not r_cas_to_tgt_rsp_req.read() )
     7516                    if (not r_cas_to_tgt_rsp_req.read() )
    77487517                    {
    77497518                        cmd_cas_fifo_get       = true;
     
    77577526
    77587527#if DEBUG_MEMC_CAS
    7759                         if(m_debug)
     7528                        if (m_debug)
    77607529                            std::cout << "  <MEMC " << name()
    77617530                                << " CAS_RSP_FAIL> Request TGT_RSP to send a failure response" << std::endl;
     
    77677536            case CAS_RSP_SUCCESS:  // request TGT_RSP FSM to send a success response
    77687537                {
    7769                     if( not r_cas_to_tgt_rsp_req.read() )
     7538                    if (not r_cas_to_tgt_rsp_req.read() )
    77707539                    {
    77717540                        cmd_cas_fifo_get       = true;
     
    77797548
    77807549#if DEBUG_MEMC_CAS
    7781                         if(m_debug)
     7550                        if (m_debug)
    77827551                            std::cout << "  <MEMC " << name()
    77837552                                << " CAS_RSP_SUCCESS> Request TGT_RSP to send a success response" << std::endl;
     
    77897558            case CAS_MISS_TRT_LOCK:         // cache miss : request access to transaction Table
    77907559                {
    7791                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_CAS)
     7560                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_CAS)
    77927561                    {
    77937562                        size_t   index = 0;
     
    77997568
    78007569#if DEBUG_MEMC_CAS
    7801                         if(m_debug)
     7570                        if (m_debug)
    78027571                        {
    78037572                            std::cout << "  <MEMC " << name() << " CAS_MISS_TRT_LOCK> Check TRT state"
     
    78097578#endif
    78107579
    7811                         if(hit_read or !wok or hit_write)    // missing line already requested or no space in TRT
     7580                        if (hit_read or !wok or hit_write)    // missing line already requested or no space in TRT
    78127581                        {
    78137582                            r_cas_fsm = CAS_WAIT;
     
    78177586                            r_cas_trt_index = index;
    78187587                            r_cas_fsm       = CAS_MISS_TRT_SET;
    7819                             m_cpt_cas_miss ++;
    7820                         }
    7821                         m_cpt_cas_fsm_n_trt_lock++;
    7822                     }
    7823 
    7824                     m_cpt_cas_fsm_trt_lock++;
    7825 
     7588                        }
     7589                    }
    78267590                    break;
    78277591                }
     
    78567620
    78577621#if DEBUG_MEMC_CAS
    7858                     if(m_debug)
     7622                    if (m_debug)
    78597623                    {
    78607624                        std::cout << "  <MEMC " << name() << " CAS_MISS_TRT_SET> Register a GET transaction in TRT" << std::hex
     
    78687632            case CAS_MISS_XRAM_REQ:  // request the IXR_CMD FSM to fetch the missing line
    78697633                {
    7870                     if( not r_cas_to_ixr_cmd_req.read() )
     7634                    if (not r_cas_to_ixr_cmd_req.read() )
    78717635                    {
    78727636                        r_cas_to_ixr_cmd_req        = true;
     
    78757639
    78767640#if DEBUG_MEMC_CAS
    7877                         if(m_debug)
     7641                        if (m_debug)
    78787642                            std::cout << "  <MEMC " << name() << " CAS_MISS_XRAM_REQ> Request a GET transaction"
    78797643                                << " / address = " << std::hex << (addr_t) m_cmd_cas_addr_fifo.read()
     
    79237687                                              m_read_to_cc_send_srcid_fifo.read() == r_cleanup_to_tgt_rsp_srcid.read();
    79247688                    // XRAM_RSP
    7925                     if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
     7689                    if (m_xram_rsp_to_cc_send_inst_fifo.rok() or
    79267690                            r_xram_rsp_to_cc_send_multi_req.read())
    79277691                    {
     
    79297693                        break;
    79307694                    }
    7931                     if(r_xram_rsp_to_cc_send_brdcast_req.read())
     7695                    if (r_xram_rsp_to_cc_send_brdcast_req.read())
    79327696                    {
    79337697                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
     
    79357699                    }
    79367700                    // CAS
    7937                     if(m_cas_to_cc_send_inst_fifo.rok() or
     7701                    if (m_cas_to_cc_send_inst_fifo.rok() or
    79387702                            r_cas_to_cc_send_multi_req.read())
    79397703                    {
     
    79417705                        break;
    79427706                    }
    7943                     if(r_cas_to_cc_send_brdcast_req.read())
     7707                    if (r_cas_to_cc_send_brdcast_req.read())
    79447708                    {
    79457709                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
     
    79487712
    79497713                    // READ
    7950                     if((m_read_to_cc_send_inst_fifo.rok() or
     7714                    if ((m_read_to_cc_send_inst_fifo.rok() or
    79517715                            r_read_to_cc_send_multi_req.read()) and not cc_send_updt_delay)
    79527716                    {
     
    79547718                        break;
    79557719                    }
    7956                     if(r_read_to_cc_send_brdcast_req.read())
     7720                    if (r_read_to_cc_send_brdcast_req.read())
    79577721                    {
    79587722                        r_cc_send_fsm = CC_SEND_READ_BRDCAST_HEADER;
     
    79617725
    79627726                    // WRITE
    7963                     if(m_write_to_cc_send_inst_fifo.rok() or
     7727                    if (m_write_to_cc_send_inst_fifo.rok() or
    79647728                            r_write_to_cc_send_multi_req.read())
    79657729                    {
     
    79677731                        break;
    79687732                    }
    7969                     if(r_write_to_cc_send_brdcast_req.read())
     7733                    if (r_write_to_cc_send_brdcast_req.read())
    79707734                    {
    79717735                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
     
    79737737                    }
    79747738                    // CONFIG
    7975                     if(r_config_to_cc_send_multi_req.read())
     7739                    if (r_config_to_cc_send_multi_req.read())
    79767740                    {
    79777741                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    79787742                        break;
    79797743                    }
    7980                     if(r_config_to_cc_send_brdcast_req.read())
     7744                    if (r_config_to_cc_send_brdcast_req.read())
    79817745                    {
    79827746                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
     
    79927756                                              m_read_to_cc_send_srcid_fifo.read() == r_cleanup_to_tgt_rsp_srcid.read();
    79937757                    // CONFIG
    7994                     if(r_config_to_cc_send_multi_req.read())
     7758                    if (r_config_to_cc_send_multi_req.read())
    79957759                    {
    79967760                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    79977761                        break;
    79987762                    }
    7999                     if(r_config_to_cc_send_brdcast_req.read())
     7763                    if (r_config_to_cc_send_brdcast_req.read())
    80007764                    {
    80017765                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
     
    80037767                    }
    80047768                    // XRAM_RSP
    8005                     if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
     7769                    if (m_xram_rsp_to_cc_send_inst_fifo.rok() or
    80067770                            r_xram_rsp_to_cc_send_multi_req.read())
    80077771                    {
     
    80097773                        break;
    80107774                    }
    8011                     if(r_xram_rsp_to_cc_send_brdcast_req.read())
     7775                    if (r_xram_rsp_to_cc_send_brdcast_req.read())
    80127776                    {
    80137777                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
     
    80157779                    }
    80167780                    // CAS
    8017                     if(m_cas_to_cc_send_inst_fifo.rok() or
     7781                    if (m_cas_to_cc_send_inst_fifo.rok() or
    80187782                            r_cas_to_cc_send_multi_req.read())
    80197783                    {
     
    80217785                        break;
    80227786                    }
    8023                     if(r_cas_to_cc_send_brdcast_req.read())
     7787                    if (r_cas_to_cc_send_brdcast_req.read())
    80247788                    {
    80257789                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
     
    80277791                    }
    80287792                    // READ
    8029                     if((m_read_to_cc_send_inst_fifo.rok() or
     7793                    if ((m_read_to_cc_send_inst_fifo.rok() or
    80307794                            r_read_to_cc_send_multi_req.read()) and not cc_send_updt_delay)
    80317795                    {
     
    80337797                        break;
    80347798                    }
    8035                     if(r_read_to_cc_send_brdcast_req.read())
     7799                    if (r_read_to_cc_send_brdcast_req.read())
    80367800                    {
    80377801                        r_cc_send_fsm = CC_SEND_READ_BRDCAST_HEADER;
     
    80397803                    }
    80407804                    // WRITE
    8041                     if(m_write_to_cc_send_inst_fifo.rok() or
     7805                    if (m_write_to_cc_send_inst_fifo.rok() or
    80427806                            r_write_to_cc_send_multi_req.read())
    80437807                    {
     
    80457809                        break;
    80467810                    }
    8047                     if(r_write_to_cc_send_brdcast_req.read())
     7811                    if (r_write_to_cc_send_brdcast_req.read())
    80487812                    {
    80497813                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
     
    80597823                                              m_read_to_cc_send_srcid_fifo.read() == r_cleanup_to_tgt_rsp_srcid.read();
    80607824                    // CAS
    8061                     if(m_cas_to_cc_send_inst_fifo.rok() or
     7825                    if (m_cas_to_cc_send_inst_fifo.rok() or
    80627826                            r_cas_to_cc_send_multi_req.read())
    80637827                    {
     
    80657829                        break;
    80667830                    }
    8067                     if(r_cas_to_cc_send_brdcast_req.read())
     7831                    if (r_cas_to_cc_send_brdcast_req.read())
    80687832                    {
    80697833                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
     
    80717835                    }
    80727836                    // READ
    8073                     if((m_read_to_cc_send_inst_fifo.rok() or
     7837                    if ((m_read_to_cc_send_inst_fifo.rok() or
    80747838                            r_read_to_cc_send_multi_req.read()) and not cc_send_updt_delay)
    80757839                    {
     
    80777841                        break;
    80787842                    }
    8079                     if(r_read_to_cc_send_brdcast_req.read())
     7843                    if (r_read_to_cc_send_brdcast_req.read())
    80807844                    {
    80817845                        r_cc_send_fsm = CC_SEND_READ_BRDCAST_HEADER;
     
    80837847                    }
    80847848                    //WRITE
    8085                     if(m_write_to_cc_send_inst_fifo.rok() or
     7849                    if (m_write_to_cc_send_inst_fifo.rok() or
    80867850                            r_write_to_cc_send_multi_req.read())
    80877851                    {
     
    80897853                        break;
    80907854                    }
    8091                     if(r_write_to_cc_send_brdcast_req.read())
     7855                    if (r_write_to_cc_send_brdcast_req.read())
    80927856                    {
    80937857                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
     
    80957859                    }
    80967860                    // CONFIG
    8097                     if(r_config_to_cc_send_multi_req.read())
     7861                    if (r_config_to_cc_send_multi_req.read())
    80987862                    {
    80997863                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    81007864                        break;
    81017865                    }
    8102                     if(r_config_to_cc_send_brdcast_req.read())
     7866                    if (r_config_to_cc_send_brdcast_req.read())
    81037867                    {
    81047868                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
     
    81067870                    }
    81077871                    // XRAM_RSP
    8108                     if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
     7872                    if (m_xram_rsp_to_cc_send_inst_fifo.rok() or
    81097873                            r_xram_rsp_to_cc_send_multi_req.read())
    81107874                    {
     
    81127876                        break;
    81137877                    }
    8114                     if(r_xram_rsp_to_cc_send_brdcast_req.read())
     7878                    if (r_xram_rsp_to_cc_send_brdcast_req.read())
    81157879                    {
    81167880                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
     
    81267890                                              m_read_to_cc_send_srcid_fifo.read() == r_cleanup_to_tgt_rsp_srcid.read();
    81277891                    // READ
    8128                     if((m_read_to_cc_send_inst_fifo.rok() or
     7892                    if ((m_read_to_cc_send_inst_fifo.rok() or
    81297893                            r_read_to_cc_send_multi_req.read()) and not cc_send_updt_delay)
    81307894                    {
     
    81327896                        break;
    81337897                    }
    8134                     if(r_read_to_cc_send_brdcast_req.read())
     7898                    if (r_read_to_cc_send_brdcast_req.read())
    81357899                    {
    81367900                        r_cc_send_fsm = CC_SEND_READ_BRDCAST_HEADER;
     
    81387902                    }
    81397903                    //WRITE
    8140                     if(m_write_to_cc_send_inst_fifo.rok() or
     7904                    if (m_write_to_cc_send_inst_fifo.rok() or
    81417905                            r_write_to_cc_send_multi_req.read())
    81427906                    {
     
    81447908                        break;
    81457909                    }
    8146                     if(r_write_to_cc_send_brdcast_req.read())
     7910                    if (r_write_to_cc_send_brdcast_req.read())
    81477911                    {
    81487912                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
     
    81507914                    }
    81517915                    // CONFIG
    8152                     if(r_config_to_cc_send_multi_req.read())
     7916                    if (r_config_to_cc_send_multi_req.read())
    81537917                    {
    81547918                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    81557919                        break;
    81567920                    }
    8157                     if(r_config_to_cc_send_brdcast_req.read())
     7921                    if (r_config_to_cc_send_brdcast_req.read())
    81587922                    {
    81597923                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
     
    81617925                    }
    81627926                    //xram
    8163                     if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
     7927                    if (m_xram_rsp_to_cc_send_inst_fifo.rok() or
    81647928                            r_xram_rsp_to_cc_send_multi_req.read())
    81657929                    {
     
    81677931                        break;
    81687932                    }
    8169                     if(r_xram_rsp_to_cc_send_brdcast_req.read())
     7933                    if (r_xram_rsp_to_cc_send_brdcast_req.read())
    81707934                    {
    81717935                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
     
    81737937                    }
    81747938                    //cas
    8175                     if(m_cas_to_cc_send_inst_fifo.rok() or
     7939                    if (m_cas_to_cc_send_inst_fifo.rok() or
    81767940                            r_cas_to_cc_send_multi_req.read())
    81777941                    {
     
    81797943                        break;
    81807944                    }
    8181                     if(r_cas_to_cc_send_brdcast_req.read())
     7945                    if (r_cas_to_cc_send_brdcast_req.read())
    81827946                    {
    81837947                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
     
    81937957                                              m_read_to_cc_send_srcid_fifo.read() == r_cleanup_to_tgt_rsp_srcid.read();
    81947958                    //WRITE
    8195                     if(m_write_to_cc_send_inst_fifo.rok() or
     7959                    if (m_write_to_cc_send_inst_fifo.rok() or
    81967960                            r_write_to_cc_send_multi_req.read())
    81977961                    {
     
    81997963                        break;
    82007964                    }
    8201                     if(r_write_to_cc_send_brdcast_req.read())
     7965                    if (r_write_to_cc_send_brdcast_req.read())
    82027966                    {
    82037967                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
     
    82057969                    }
    82067970                    // CONFIG
    8207                     if(r_config_to_cc_send_multi_req.read())
     7971                    if (r_config_to_cc_send_multi_req.read())
    82087972                    {
    82097973                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    82107974                        break;
    82117975                    }
    8212                     if(r_config_to_cc_send_brdcast_req.read())
     7976                    if (r_config_to_cc_send_brdcast_req.read())
    82137977                    {
    82147978                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
     
    82167980                    }
    82177981                    //xram
    8218                     if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
     7982                    if (m_xram_rsp_to_cc_send_inst_fifo.rok() or
    82197983                            r_xram_rsp_to_cc_send_multi_req.read())
    82207984                    {
     
    82227986                        break;
    82237987                    }
    8224                     if(r_xram_rsp_to_cc_send_brdcast_req.read())
     7988                    if (r_xram_rsp_to_cc_send_brdcast_req.read())
    82257989                    {
    82267990                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
     
    82287992                    }
    82297993                    //cas
    8230                     if(m_cas_to_cc_send_inst_fifo.rok() or
     7994                    if (m_cas_to_cc_send_inst_fifo.rok() or
    82317995                            r_cas_to_cc_send_multi_req.read())
    82327996                    {
     
    82347998                        break;
    82357999                    }
    8236                     if(r_cas_to_cc_send_brdcast_req.read())
     8000                    if (r_cas_to_cc_send_brdcast_req.read())
    82378001                    {
    82388002                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
     
    82408004                    }
    82418005                    // READ
    8242                     if((m_read_to_cc_send_inst_fifo.rok() or
     8006                    if ((m_read_to_cc_send_inst_fifo.rok() or
    82438007                            r_read_to_cc_send_multi_req.read()) and not cc_send_updt_delay)
    82448008                    {
     
    82468010                        break;
    82478011                    }
    8248                     if(r_read_to_cc_send_brdcast_req.read())
     8012                    if (r_read_to_cc_send_brdcast_req.read())
    82498013                    {
    82508014                        r_cc_send_fsm = CC_SEND_READ_BRDCAST_HEADER;
     
    82578021            case CC_SEND_CONFIG_INVAL_HEADER:   // send first flit multi-inval (from CONFIG FSM)
    82588022                {
    8259                     if(m_config_to_cc_send_inst_fifo.rok())
    8260                     {
    8261                         if(not p_dspin_m2p.read) break;
     8023                    if (m_config_to_cc_send_inst_fifo.rok())
     8024                    {
     8025                        if (not p_dspin_m2p.read) break;
     8026
    82628027                        // <Activity Counters>
    82638028                        if (is_local_req(m_config_to_cc_send_srcid_fifo.read()))
     
    82688033                        {
    82698034                            m_cpt_minval_remote++;
    8270                             m_cpt_minval_cost += req_distance(m_config_to_cc_send_srcid_fifo.read());
    8271                         }
    8272                         // </Activity Counters>
    8273                         m_cpt_minval++;
     8035                        }
     8036                        // 2 flits for multi inval
     8037                        m_cpt_minval_cost += 2 * req_distance(m_config_to_cc_send_srcid_fifo.read());
    82748038                        // </Activity Counters>
    82758039                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    82768040                        break;
    82778041                    }
    8278                     if(r_config_to_cc_send_multi_req.read()) r_config_to_cc_send_multi_req = false;
     8042                    if (r_config_to_cc_send_multi_req.read()) r_config_to_cc_send_multi_req = false;
     8043                    // <Activity Counters>
     8044                    m_cpt_minval++;
     8045                    // </Activity Counters>
    82798046                    r_cc_send_fsm = CC_SEND_CONFIG_IDLE;
    82808047                    break;
     
    82838050            case CC_SEND_CONFIG_INVAL_NLINE:    // send second flit multi-inval (from CONFIG FSM)
    82848051                {
    8285                     if(not p_dspin_m2p.read) break;
     8052                    if (not p_dspin_m2p.read) break;
    82868053                    config_to_cc_send_fifo_get = true;
    82878054                    r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    82888055
    82898056#if DEBUG_MEMC_CC_SEND
    8290                     if(m_debug)
     8057                    if (m_debug)
    82918058                        std::cout << "  <MEMC " << name()
    82928059                            << " CC_SEND_CONFIG_INVAL_NLINE> multi-inval for line "
     
    82988065            case CC_SEND_CONFIG_BRDCAST_HEADER:   // send first flit BC-inval (from CONFIG FSM)
    82998066                {
    8300                     if(not p_dspin_m2p.read) break;
     8067                    if (not p_dspin_m2p.read) break;
    83018068                    r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_NLINE;
    83028069                    break;
     
    83058072            case CC_SEND_CONFIG_BRDCAST_NLINE:    // send second flit BC-inval (from CONFIG FSM)
    83068073                {
    8307                     if(not p_dspin_m2p.read) break;
     8074                    if (not p_dspin_m2p.read) break;
    83088075                    // <Activity Counters>
    83098076                    m_cpt_binval++;
     
    83138080
    83148081#if DEBUG_MEMC_CC_SEND
    8315                     if(m_debug)
     8082                    if (m_debug)
    83168083                        std::cout << "  <MEMC " << name()
    83178084                            << " CC_SEND_CONFIG_BRDCAST_NLINE> BC-Inval for line "
     
    83208087                    break;
    83218088                }
    8322                 ///////////////////////////////////
    8323             case CC_SEND_XRAM_RSP_INVAL_HEADER:   // send first flit multi-inval (from XRAM_RSP FSM)
    8324                 {
    8325                     if(m_xram_rsp_to_cc_send_inst_fifo.rok())
    8326                     {
    8327                         if(not p_dspin_m2p.read) break;
     8089            ///////////////////////////////////
     8090            case CC_SEND_XRAM_RSP_INVAL_HEADER:
     8091                // send first flit multi-inval (from XRAM_RSP FSM)
     8092                {
     8093                    if (m_xram_rsp_to_cc_send_inst_fifo.rok())
     8094                    {
     8095                        if (not p_dspin_m2p.read) break;
    83288096                        // <Activity Counters>
    83298097                        if (is_local_req(m_xram_rsp_to_cc_send_srcid_fifo.read()))
     
    83348102                        {
    83358103                            m_cpt_minval_remote++;
    8336                             m_cpt_minval_cost += req_distance(m_xram_rsp_to_cc_send_srcid_fifo.read());
    8337                         }
    8338                         // </Activity Counters>
    8339                         m_cpt_minval++;
     8104                        }
     8105                        // 2 flits for multi inval
     8106                        m_cpt_minval_cost += 2 * req_distance(m_xram_rsp_to_cc_send_srcid_fifo.read());
    83408107                        // </Activity Counters>
    83418108                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    83428109                        break;
    83438110                    }
    8344                     if(r_xram_rsp_to_cc_send_multi_req.read()) r_xram_rsp_to_cc_send_multi_req = false;
    8345 
     8111                    if (r_xram_rsp_to_cc_send_multi_req.read()) r_xram_rsp_to_cc_send_multi_req = false;
     8112 
     8113                    // <Activity Counters>
     8114                    m_cpt_minval++;
     8115                    // </Activity Counters>
    83468116                    r_cc_send_fsm = CC_SEND_XRAM_RSP_IDLE;
    83478117                    break;
     
    83508120            case CC_SEND_XRAM_RSP_INVAL_NLINE:   // send second flit multi-inval (from XRAM_RSP FSM)
    83518121                {
    8352                     if(not p_dspin_m2p.read) break;
     8122                    if (not p_dspin_m2p.read) break;
    83538123                    xram_rsp_to_cc_send_fifo_get = true;
    83548124                    r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    83558125
    83568126#if DEBUG_MEMC_CC_SEND
    8357                     if(m_debug)
     8127                    if (m_debug)
    83588128                        std::cout << "  <MEMC " << name()
    83598129                            << " CC_SEND_XRAM_RSP_INVAL_NLINE> Multicast-Inval for line "
     
    83658135            case CC_SEND_XRAM_RSP_BRDCAST_HEADER:  // send first flit broadcast-inval (from XRAM_RSP FSM)
    83668136                {
    8367                     if(not p_dspin_m2p.read) break;
     8137                    if (not p_dspin_m2p.read) break;
    83688138                    r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_NLINE;
    83698139                    break;
     
    83728142            case CC_SEND_XRAM_RSP_BRDCAST_NLINE:   // send second flit broadcast-inval (from XRAM_RSP FSM)
    83738143                {
    8374                     if(not p_dspin_m2p.read) break;
     8144                    if (not p_dspin_m2p.read) break;
    83758145                    // <Activity Counters>
    83768146                    m_cpt_binval++;
     
    83808150
    83818151#if DEBUG_MEMC_CC_SEND
    8382                     if(m_debug)
     8152                    if (m_debug)
    83838153                        std::cout << "  <MEMC " << name()
    83848154                            << " CC_SEND_XRAM_RSP_BRDCAST_NLINE> BC-Inval for line "
     
    83908160            case CC_SEND_READ_BRDCAST_HEADER:
    83918161                {
    8392                     if(not p_dspin_m2p.read) break;
     8162                    if (not p_dspin_m2p.read) break;
    83938163                    // <Activity Counters>
    83948164                    m_cpt_binval++;
     
    83998169            case CC_SEND_READ_BRDCAST_NLINE:
    84008170                {
    8401                     if(not p_dspin_m2p.read) break;
     8171                    if (not p_dspin_m2p.read) break;
    84028172                    r_read_to_cc_send_brdcast_req = false;
    84038173                    r_cc_send_fsm = CC_SEND_READ_IDLE;
     
    84068176            case CC_SEND_READ_MULTI_HEADER:
    84078177                {
    8408                     if(m_read_to_cc_send_inst_fifo.rok())
    8409                     {
    8410                         if(not p_dspin_m2p.read) break;
     8178                    if (m_read_to_cc_send_inst_fifo.rok())
     8179                    {
     8180                        if (not p_dspin_m2p.read) break;
     8181
    84118182                        // <Activity Counters>
    8412                         if (is_local_req(m_read_to_cc_send_srcid_fifo.read()))
    8413                         {
    8414                             if(r_read_to_cc_send_type.read())
    8415                                 m_cpt_minval_local ++;
    8416                             else
    8417                                 m_cpt_update_local ++;
    8418                         }
    8419                         else
    8420                         {
    8421                             if(r_read_to_cc_send_type.read())
     8183                        if (r_read_to_cc_send_type.read()) {
     8184                            // Can be either an inval RO or a multi inval;
     8185                            // Counting only multi inval here
     8186                            if (is_local_req(m_read_to_cc_send_srcid_fifo.read()))
    84228187                            {
    8423                                 m_cpt_minval_remote++;
    8424                                 m_cpt_minval_cost += req_distance(m_read_to_cc_send_srcid_fifo.read());
     8188                                m_cpt_minval_local++;
    84258189                            }
    84268190                            else
    84278191                            {
    8428                                 m_cpt_update_remote++;
    8429                                 m_cpt_update_cost += req_distance(m_read_to_cc_send_srcid_fifo.read());
     8192                                m_cpt_minval_remote++;
    84308193                            }
    8431                         }
    8432                         // </Activity Counters>
    8433                         if(r_read_to_cc_send_type.read())
    8434                             m_cpt_minval++;
     8194                            // 2 flits for multi inval
     8195                            m_cpt_minval_cost += 2 * req_distance(m_read_to_cc_send_srcid_fifo.read());
     8196                        }
    84358197                        // </Activity Counters>
    84368198                        r_cc_send_fsm = CC_SEND_READ_MULTI_NLINE;
     
    84388200                    }
    84398201
    8440                     if(r_read_to_cc_send_multi_req.read())
     8202                    if (r_read_to_cc_send_multi_req.read())
    84418203                    {
    84428204                       r_read_to_cc_send_multi_req = false;
    84438205                    }
    84448206
     8207                    // <Activity Counters>
     8208                    m_cpt_minval++;
     8209                    // </Activity Counters>
    84458210                    r_cc_send_fsm = CC_SEND_READ_IDLE;
    84468211                    break;
     
    84498214            case CC_SEND_READ_MULTI_NLINE:
    84508215                {
    8451                     if(not p_dspin_m2p.read) break;
     8216                    if (not p_dspin_m2p.read) break;
    84528217
    84538218                    read_to_cc_send_fifo_get = true;
     
    84558220
    84568221#if DEBUG_MEMC_CC_SEND
    8457                     if(m_debug)
     8222                    if (m_debug)
    84588223                    {
    84598224                        std::cout
     
    84698234            case CC_SEND_WRITE_BRDCAST_HEADER:   // send first flit broadcast-inval (from WRITE FSM)
    84708235                {
    8471                     if(not p_dspin_m2p.read) break;
     8236                    if (not p_dspin_m2p.read) break;
    84728237                    r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_NLINE;
    84738238                    break;
     
    84768241            case CC_SEND_WRITE_BRDCAST_NLINE:   // send second flit broadcast-inval (from WRITE FSM)
    84778242                {
    8478                     if(not p_dspin_m2p.read) break;
     8243                    if (not p_dspin_m2p.read) break;
    84798244
    84808245                    // <Activity Counters>
     
    84868251
    84878252#if DEBUG_MEMC_CC_SEND
    8488                     if(m_debug)
     8253                    if (m_debug)
    84898254                        std::cout << "  <MEMC " << name()
    84908255                            << " CC_SEND_WRITE_BRDCAST_NLINE> BC-Inval for line "
     
    84968261            case CC_SEND_WRITE_INVAL_HEADER:   // send first flit for a multi-inval (from WRITE FSM)
    84978262                {
    8498                     if(m_write_to_cc_send_inst_fifo.rok())
    8499                     {
    8500                         if(not p_dspin_m2p.read) break;
     8263                    if (m_write_to_cc_send_inst_fifo.rok())
     8264                    {
     8265                        if (not p_dspin_m2p.read) break;
    85018266                        // <Activity Counters>
    85028267                        if (is_local_req(m_write_to_cc_send_srcid_fifo.read()))
     
    85078272                        {
    85088273                            m_cpt_minval_remote++;
    8509                             m_cpt_minval_cost += req_distance(m_write_to_cc_send_srcid_fifo.read());
    8510                         }
    8511                         // </Activity Counters>
    8512                         m_cpt_minval++;
     8274                        }
     8275                        // 2 flits for multi inval
     8276                        m_cpt_minval_cost += 2 * req_distance(m_write_to_cc_send_srcid_fifo.read());
    85138277                        // </Activity Counters>
    85148278                        r_cc_send_fsm = CC_SEND_WRITE_INVAL_NLINE;
     
    85168280                    }
    85178281
    8518                     if(r_write_to_cc_send_multi_req.read())
     8282                    if (r_write_to_cc_send_multi_req.read())
    85198283                    {
    85208284                        r_write_to_cc_send_multi_req = false;
    85218285                    }
    85228286
     8287                    // <Activity Counters>
     8288                    m_cpt_minval++;
     8289                    // </Activity Counters>
    85238290                    r_cc_send_fsm = CC_SEND_WRITE_IDLE;
    85248291                    break;
     
    85278294            case CC_SEND_WRITE_INVAL_NLINE:   // send second flit for a multi-update (from WRITE FSM)
    85288295                {
    8529                     if(not p_dspin_m2p.read) break;
     8296                    if (not p_dspin_m2p.read) break;
    85308297                    write_to_cc_send_fifo_get = true;
    85318298                    r_cc_send_fsm = CC_SEND_WRITE_INVAL_HEADER;
    85328299
    85338300#if DEBUG_MEMC_CC_SEND
    8534                     if(m_debug)
     8301                    if (m_debug)
    85358302                        std::cout << "  <MEMC " << name()
    85368303                            << " CC_SEND_WRITE_INVAL_NLINE> Multicast-Inval for line "
     
    85428309            case CC_SEND_CAS_BRDCAST_HEADER:   // send first flit  broadcast-inval (from CAS FSM)
    85438310                {
    8544                     if(not p_dspin_m2p.read) break;
     8311                    if (not p_dspin_m2p.read) break;
    85458312                    r_cc_send_fsm = CC_SEND_CAS_BRDCAST_NLINE;
    85468313                    break;
     
    85498316            case CC_SEND_CAS_BRDCAST_NLINE:   // send second flit broadcast-inval (from CAS FSM)
    85508317                {
    8551                     if(not p_dspin_m2p.read) break;
     8318                    if (not p_dspin_m2p.read) break;
    85528319                    // <Activity Counters>
    85538320                    m_cpt_binval++;
     
    85588325
    85598326#if DEBUG_MEMC_CC_SEND
    8560                     if(m_debug)
     8327                    if (m_debug)
    85618328                        std::cout << "  <MEMC " << name()
    85628329                            << " CC_SEND_CAS_BRDCAST_NLINE> Broadcast-Inval for line "
     
    85688335            case CC_SEND_CAS_INVAL_HEADER:   // send first flit for a multi-update (from CAS FSM)
    85698336                {
    8570                     if(m_cas_to_cc_send_inst_fifo.rok())
    8571                     {
    8572                         if(not p_dspin_m2p.read) break;
     8337                    if (m_cas_to_cc_send_inst_fifo.rok())
     8338                    {
     8339                        if (not p_dspin_m2p.read) break;
    85738340                        // <Activity Counters>
    85748341                        if (is_local_req(m_cas_to_cc_send_srcid_fifo.read()))
     
    85798346                        {
    85808347                            m_cpt_minval_remote++;
    8581                             m_cpt_minval_cost += req_distance(m_cas_to_cc_send_srcid_fifo.read());
    8582                         }
    8583                         // <Activity Counters>
    8584                         m_cpt_minval++;
     8348                        }
     8349                        // 2 flits for multi inval
     8350                        m_cpt_minval_cost += 2 * req_distance(m_cas_to_cc_send_srcid_fifo.read());
    85858351                        // </Activity Counters>
    85868352                        r_cc_send_fsm = CC_SEND_CAS_INVAL_NLINE;
     
    85898355
    85908356                    // no more packets to send for the multi-update
    8591                     if(r_cas_to_cc_send_multi_req.read())
     8357                    if (r_cas_to_cc_send_multi_req.read())
    85928358                    {
    85938359                        r_cas_to_cc_send_multi_req = false;
    85948360                    }
    85958361
     8362                    // <Activity Counters>
     8363                    m_cpt_minval++;
     8364                    // </Activity Counters>
    85968365                    r_cc_send_fsm = CC_SEND_CAS_IDLE;
    85978366                    break;
     
    86008369            case CC_SEND_CAS_INVAL_NLINE:   // send second flit for a multi-update (from CAS FSM)
    86018370                {
    8602                     if(not p_dspin_m2p.read) break;
     8371                    if (not p_dspin_m2p.read) break;
    86038372                    cas_to_cc_send_fifo_get = true;
    86048373                    r_cc_send_fsm = CC_SEND_CAS_INVAL_HEADER;
    86058374
    86068375#if DEBUG_MEMC_CC_SEND
    8607                     if(m_debug)
     8376                    if (m_debug)
    86088377                        std::cout << "  <MEMC " << name()
    86098378                            << " CC_SEND_CAS_INVAL_NLINE> Multicast-Inval for line "
     
    86278396            case CC_RECEIVE_IDLE:
    86288397                {
    8629                     if(not p_dspin_p2m.write) break;
     8398                    if (not p_dspin_p2m.write) break;
    86308399
    86318400                    uint8_t type =
    8632                         DspinDhccpParam::dspin_get(
     8401                        DspinHmesiParam::dspin_get(
    86338402                                p_dspin_p2m.data.read(),
    8634                                 DspinDhccpParam::P2M_TYPE);
    8635 
    8636                     if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
    8637                             (type == DspinDhccpParam::TYPE_CLEANUP_INST))
     8403                                DspinHmesiParam::P2M_TYPE);
     8404
     8405                    if ((type == DspinHmesiParam::TYPE_CLEANUP_DATA) or
     8406                            (type == DspinHmesiParam::TYPE_CLEANUP_INST))
    86388407                    {
    86398408                        r_cc_receive_fsm = CC_RECEIVE_CLEANUP;
     
    86418410                    }
    86428411
    8643                     if(type == DspinDhccpParam::TYPE_MULTI_ACK)
     8412                    if (type == DspinHmesiParam::TYPE_MULTI_ACK)
    86448413                    {
    86458414                        r_cc_receive_fsm = CC_RECEIVE_MULTI_ACK;
     
    86588427                    // write first CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    86598428
    8660                     if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
     8429                    if (not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    86618430                        break;
    86628431
    86638432                    cc_receive_to_cleanup_fifo_put = true;
    8664                     if(p_dspin_p2m.eop.read())
     8433                    if (p_dspin_p2m.eop.read())
    86658434                        r_cc_receive_fsm               = CC_RECEIVE_IDLE;
    86668435
     
    86728441                    // write second CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    86738442
    8674                     if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
     8443                    if (not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    86758444                        break;
    86768445
     
    86808449
    86818450                    cc_receive_to_cleanup_fifo_put = true;
    8682                     if(p_dspin_p2m.eop.read())
     8451                    if (p_dspin_p2m.eop.read())
    86838452                        r_cc_receive_fsm               = CC_RECEIVE_IDLE;
    86848453                    break;
     
    86918460
    86928461                    // wait for a WOK in the CC_RECEIVE to MULTI_ACK fifo
    8693                     if(not p_dspin_p2m.write or not m_cc_receive_to_multi_ack_fifo.wok())
     8462                    if (not p_dspin_p2m.write or not m_cc_receive_to_multi_ack_fifo.wok())
    86948463                        break;
    86958464
    8696                     if( p_dspin_p2m.eop.read())
     8465                    if (p_dspin_p2m.eop.read())
    86978466                        r_cc_receive_fsm             = CC_RECEIVE_IDLE;
    86988467
     
    87248493            case TGT_RSP_CONFIG_IDLE:  // tgt_cmd requests have the highest priority
    87258494                {
    8726                     if(r_tgt_cmd_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8727                     else if(r_read_to_tgt_rsp_req)
     8495                    if (r_tgt_cmd_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8496                    else if (r_read_to_tgt_rsp_req)
    87288497                    {
    87298498                        r_tgt_rsp_fsm = TGT_RSP_READ;
    87308499                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    87318500                    }
    8732                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8733                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
    8734                     else if(r_xram_rsp_to_tgt_rsp_req)
     8501                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8502                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
     8503                    else if (r_xram_rsp_to_tgt_rsp_req)
    87358504                    {
    87368505                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    87378506                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    87388507                    }
    8739                     else if(r_multi_ack_to_tgt_rsp_req)
     8508                    else if (r_multi_ack_to_tgt_rsp_req)
    87408509                    {
    87418510                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    87428511                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    87438512                    }
    8744                     else if(r_cleanup_to_tgt_rsp_req) 
     8513                    else if (r_cleanup_to_tgt_rsp_req) 
    87458514                    {
    87468515                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    87478516                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    87488517                    }
    8749                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8518                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    87508519                    break;
    87518520                }
     
    87538522            case TGT_RSP_TGT_CMD_IDLE: // read requests have the highest priority
    87548523                {
    8755                     if(r_read_to_tgt_rsp_req)
     8524                    if (r_read_to_tgt_rsp_req)
    87568525                    {
    87578526                        r_tgt_rsp_fsm = TGT_RSP_READ;
    87588527                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    87598528                    }
    8760                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8761                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
    8762                     else if(r_xram_rsp_to_tgt_rsp_req)
     8529                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8530                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
     8531                    else if (r_xram_rsp_to_tgt_rsp_req)
    87638532                    {
    87648533                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    87658534                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    87668535                    }
    8767                     else if(r_multi_ack_to_tgt_rsp_req)
     8536                    else if (r_multi_ack_to_tgt_rsp_req)
    87688537                    {
    87698538                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    87708539                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    87718540                    }
    8772                     else if(r_cleanup_to_tgt_rsp_req)
     8541                    else if (r_cleanup_to_tgt_rsp_req)
    87738542                    {
    87748543                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    87758544                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    87768545                    }
    8777                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8778                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8546                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8547                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    87798548                    break;
    87808549                }
     
    87828551            case TGT_RSP_READ_IDLE: // write requests have the highest priority
    87838552                {
    8784                     if(r_write_to_tgt_rsp_req)          r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8785                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
    8786                     else if(r_xram_rsp_to_tgt_rsp_req)
     8553                    if (r_write_to_tgt_rsp_req)          r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8554                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
     8555                    else if (r_xram_rsp_to_tgt_rsp_req)
    87878556                    {
    87888557                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    87898558                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    87908559                    }
    8791                     else if(r_multi_ack_to_tgt_rsp_req)
     8560                    else if (r_multi_ack_to_tgt_rsp_req)
    87928561                    {
    87938562                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    87948563                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    87958564                    }
    8796                     else if(r_cleanup_to_tgt_rsp_req)
     8565                    else if (r_cleanup_to_tgt_rsp_req)
    87978566                    {
    87988567                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    87998568                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    88008569                    }
    8801                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8802                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8803                     else if(r_read_to_tgt_rsp_req)
     8570                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8571                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8572                    else if (r_read_to_tgt_rsp_req)
    88048573                    {
    88058574                        r_tgt_rsp_fsm = TGT_RSP_READ;
     
    88118580            case TGT_RSP_WRITE_IDLE: // cas requests have the highest priority
    88128581                {
    8813                     if(r_cas_to_tgt_rsp_req)            r_tgt_rsp_fsm = TGT_RSP_CAS;
    8814                     else if(r_xram_rsp_to_tgt_rsp_req)
     8582                    if (r_cas_to_tgt_rsp_req)            r_tgt_rsp_fsm = TGT_RSP_CAS;
     8583                    else if (r_xram_rsp_to_tgt_rsp_req)
    88158584                    {
    88168585                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    88178586                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    88188587                    }
    8819                     else if(r_multi_ack_to_tgt_rsp_req)
     8588                    else if (r_multi_ack_to_tgt_rsp_req)
    88208589                    {
    88218590                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    88228591                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    88238592                    }
    8824                     else if(r_cleanup_to_tgt_rsp_req)
     8593                    else if (r_cleanup_to_tgt_rsp_req)
    88258594                    {
    88268595                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    88278596                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    88288597                    }
    8829                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8830                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8831                     else if(r_read_to_tgt_rsp_req)
     8598                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8599                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8600                    else if (r_read_to_tgt_rsp_req)
    88328601                    {
    88338602                        r_tgt_rsp_fsm = TGT_RSP_READ;
    88348603                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    88358604                    }
    8836                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8605                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    88378606                    break;
    88388607                }
     
    88408609            case TGT_RSP_CAS_IDLE: // xram_rsp requests have the highest priority
    88418610                {
    8842                     if(r_xram_rsp_to_tgt_rsp_req)
     8611                    if (r_xram_rsp_to_tgt_rsp_req)
    88438612                    {
    88448613                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    88458614                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    88468615                    }
    8847                     else if(r_multi_ack_to_tgt_rsp_req)
     8616                    else if (r_multi_ack_to_tgt_rsp_req)
    88488617                    {
    88498618                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    88508619                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    88518620                    }
    8852                     else if(r_cleanup_to_tgt_rsp_req)
     8621                    else if (r_cleanup_to_tgt_rsp_req)
    88538622                    {
    88548623                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    88558624                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    88568625                    }
    8857                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8858                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8859                     else if(r_read_to_tgt_rsp_req)
     8626                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8627                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8628                    else if (r_read_to_tgt_rsp_req)
    88608629                    {
    88618630                        r_tgt_rsp_fsm = TGT_RSP_READ;
    88628631                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    88638632                    }
    8864                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8865                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
     8633                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8634                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
    88668635                    break;
    88678636                }
     
    88698638            case TGT_RSP_XRAM_IDLE: // multi ack requests have the highest priority
    88708639                {
    8871                     if(r_multi_ack_to_tgt_rsp_req.read())
     8640                    if (r_multi_ack_to_tgt_rsp_req.read())
    88728641                    {
    88738642                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    88748643                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    88758644                    }
    8876                     else if(r_cleanup_to_tgt_rsp_req)
     8645                    else if (r_cleanup_to_tgt_rsp_req)
    88778646                    {
    88788647                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    88798648                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    88808649                    }
    8881                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8882                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8883                     else if(r_read_to_tgt_rsp_req)
     8650                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8651                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8652                    else if (r_read_to_tgt_rsp_req)
    88848653                    {
    88858654                        r_tgt_rsp_fsm = TGT_RSP_READ;
    88868655                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    88878656                    }
    8888                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8889                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
    8890                     else if(r_xram_rsp_to_tgt_rsp_req)
     8657                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8658                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
     8659                    else if (r_xram_rsp_to_tgt_rsp_req)
    88918660                    {
    88928661                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
     
    88988667            case TGT_RSP_MULTI_ACK_IDLE: // cleanup requests have the highest priority
    88998668                {
    8900                     if(r_cleanup_to_tgt_rsp_req)
     8669                    if (r_cleanup_to_tgt_rsp_req)
    89018670                    {
    89028671                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    89038672                        r_tgt_rsp_cpt = r_cleanup_to_tgt_rsp_first_word.read();
    89048673                    }
    8905                     else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8906                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8907                     else if(r_read_to_tgt_rsp_req)
     8674                    else if (r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8675                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8676                    else if (r_read_to_tgt_rsp_req)
    89088677                    {
    89098678                        r_tgt_rsp_fsm = TGT_RSP_READ;
    89108679                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    89118680                    }
    8912                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8913                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
    8914                     else if(r_xram_rsp_to_tgt_rsp_req)
     8681                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8682                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
     8683                    else if (r_xram_rsp_to_tgt_rsp_req)
    89158684                    {
    89168685                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    89178686                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    89188687                    }
    8919                     else if(r_multi_ack_to_tgt_rsp_req)
     8688                    else if (r_multi_ack_to_tgt_rsp_req)
    89208689                    {
    89218690                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
     
    89278696            case TGT_RSP_CLEANUP_IDLE: // tgt cmd requests have the highest priority
    89288697                {
    8929                     if(r_config_to_tgt_rsp_req)         r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    8930                     else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    8931                     else if(r_read_to_tgt_rsp_req)
     8698                    if (r_config_to_tgt_rsp_req)         r_tgt_rsp_fsm = TGT_RSP_CONFIG;
     8699                    else if (r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     8700                    else if (r_read_to_tgt_rsp_req)
    89328701                    {
    89338702                        r_tgt_rsp_fsm = TGT_RSP_READ;
    89348703                        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    89358704                    }
    8936                     else if(r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
    8937                     else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
    8938                     else if(r_xram_rsp_to_tgt_rsp_req)
     8705                    else if (r_write_to_tgt_rsp_req)     r_tgt_rsp_fsm = TGT_RSP_WRITE;
     8706                    else if (r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS  ;
     8707                    else if (r_xram_rsp_to_tgt_rsp_req)
    89398708                    {
    89408709                        r_tgt_rsp_fsm = TGT_RSP_XRAM;
    89418710                        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    89428711                    }
    8943                     else if(r_multi_ack_to_tgt_rsp_req)
     8712                    else if (r_multi_ack_to_tgt_rsp_req)
    89448713                    {
    89458714                        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    89468715                        r_tgt_rsp_cpt = r_multi_ack_to_tgt_rsp_word.read();
    89478716                    }
    8948                     else if(r_cleanup_to_tgt_rsp_req)
     8717                    else if (r_cleanup_to_tgt_rsp_req)
    89498718                    {
    89508719                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     
    89568725            case TGT_RSP_CONFIG:  // send the response for a config transaction
    89578726                {
    8958                     if ( p_vci_tgt.rspack )
     8727                    if (p_vci_tgt.rspack )
    89598728                    {
    89608729                        r_config_to_tgt_rsp_req = false;
     
    89628731
    89638732#if DEBUG_MEMC_TGT_RSP
    8964                         if( m_debug )
     8733                        if (m_debug )
    89658734                        {
    89668735                            std::cout
     
    89798748            case TGT_RSP_TGT_CMD: // send the response for a configuration access
    89808749                {
    8981                     if ( p_vci_tgt.rspack )
     8750                    if (p_vci_tgt.rspack )
    89828751                    {
    89838752                        r_tgt_cmd_to_tgt_rsp_req = false;
     
    89858754
    89868755#if DEBUG_MEMC_TGT_RSP
    8987                         if( m_debug )
     8756                        if (m_debug )
    89888757                        {
    89898758                            std::cout
     
    90038772            case TGT_RSP_READ:    // send the response to a read
    90048773                {
    9005                     if ( p_vci_tgt.rspack )
     8774                    if (p_vci_tgt.rspack )
    90068775                    {
    90078776
    90088777#if DEBUG_MEMC_TGT_RSP
    9009                         if( m_debug )
     8778                        if (m_debug )
    90108779                        {
    90118780                            std::cout
     
    90508819            case TGT_RSP_WRITE:   // send the write acknowledge
    90518820                {
    9052                     if(p_vci_tgt.rspack)
     8821                    if (p_vci_tgt.rspack)
    90538822                    {
    90548823
    90558824#if DEBUG_MEMC_TGT_RSP
    9056                         if(m_debug)
     8825                        if (m_debug)
    90578826                            std::cout << "  <MEMC " << name() << " TGT_RSP_WRITE> Write response"
    90588827                                << " / rsrcid = " << std::hex << r_write_to_tgt_rsp_srcid.read()
     
    90688837            case TGT_RSP_CLEANUP:   // pas clair pour moi (AG)
    90698838                {
    9070                     if(p_vci_tgt.rspack)
     8839                    if (p_vci_tgt.rspack)
    90718840                    {
    90728841                        uint32_t last_word_idx = r_cleanup_to_tgt_rsp_first_word.read() + r_cleanup_to_tgt_rsp_length.read() - 1;
    90738842                        bool is_ll    = ((r_cleanup_to_tgt_rsp_pktid.read() & 0x7) == TYPE_LL);
    90748843#if DEBUG_MEMC_TGT_RSP
    9075                         if(m_debug)
     8844                        if (m_debug)
    90768845                        {
    90778846                            std::cout << "  <MEMC " << name() << " TGT_RSP_CLEANUP> Cleanup response"
     
    91118880            case TGT_RSP_CAS:    // send one atomic word response
    91128881                {
    9113                     if(p_vci_tgt.rspack)
     8882                    if (p_vci_tgt.rspack)
    91148883                    {
    91158884
    91168885#if DEBUG_MEMC_TGT_RSP
    9117                         if(m_debug)
     8886                        if (m_debug)
    91188887                            std::cout << "  <MEMC " << name() << " TGT_RSP_CAS> CAS response"
    91198888                                << " / rsrcid = " << std::hex << r_cas_to_tgt_rsp_srcid.read()
     
    91298898            case TGT_RSP_XRAM:    // send the response after XRAM access
    91308899                {
    9131                     if ( p_vci_tgt.rspack )
     8900                    if (p_vci_tgt.rspack )
    91328901                    {
    91338902
    91348903#if DEBUG_MEMC_TGT_RSP
    9135                         if( m_debug )
     8904                        if (m_debug )
    91368905                            std::cout << "  <MEMC " << name() << " TGT_RSP_XRAM> Response following XRAM access"
    91378906                                << " / rsrcid = " << std::hex << r_xram_rsp_to_tgt_rsp_srcid.read()
     
    91728941            case TGT_RSP_MULTI_ACK:    // send the read /LL response after coherence transaction
    91738942                {
    9174                     if(p_vci_tgt.rspack)
     8943                    if (p_vci_tgt.rspack)
    91758944                    {
    91768945
     
    91828951
    91838952#if DEBUG_MEMC_TGT_RSP
    9184                         if(m_debug)
     8953                        if (m_debug)
    91858954                            std::cout << "  <MEMC " << name() << " TGT_RSP_MULTI_ACK> Write response after coherence transaction"
    91868955                                << " / rsrcid = " << std::hex << r_multi_ack_to_tgt_rsp_srcid.read()
     
    92359004                if (r_write_fsm.read() != WRITE_INVAL_IVT_LOCK)
    92369005                {
    9237                     if((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
     9006                    if ((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
    92389007                       (r_read_fsm.read() == READ_IVT_UPDT_LOCK))
    92399008                        r_alloc_ivt_fsm = ALLOC_IVT_READ;
     
    92559024                        r_alloc_ivt_fsm = ALLOC_IVT_MULTI_ACK;
    92569025
    9257                     else
    9258                         m_cpt_ivt_unused++;
    92599026                }
    92609027                break;
     
    92629029                //////////////////////////
    92639030            case ALLOC_IVT_READ:            // allocated to READ FSM
    9264                if((r_read_fsm.read() != READ_IVT_INVAL_LOCK) and
     9031               if ((r_read_fsm.read() != READ_IVT_INVAL_LOCK) and
    92659032                  (r_read_fsm.read() != READ_IVT_UPDT_LOCK))
    92669033               {
     
    92849051                        r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
    92859052
    9286                     else
    9287                         m_cpt_ivt_unused++;
    92889053                }
    92899054                break;
     
    92919056                //////////////////////////
    92929057            case ALLOC_IVT_XRAM_RSP:         // allocated to XRAM_RSP FSM
    9293                 if(r_xram_rsp_fsm.read() != XRAM_RSP_IVT_LOCK)
     9058                if (r_xram_rsp_fsm.read() != XRAM_RSP_IVT_LOCK)
    92949059                {
    92959060                    if ((r_cleanup_fsm.read() == CLEANUP_MISS_IVT_LOCK) or
     
    93099074                        r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
    93109075
    9311                     else if((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
     9076                    else if ((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
    93129077                            (r_read_fsm.read() == READ_IVT_UPDT_LOCK))
    93139078                        r_alloc_ivt_fsm = ALLOC_IVT_READ;
    93149079
    9315                     else
    9316                         m_cpt_ivt_unused++;
    93179080                }
    93189081                break;
     
    93379100                        r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
    93389101
    9339                     else if((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
     9102                    else if ((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
    93409103                           (r_read_fsm.read() == READ_IVT_UPDT_LOCK))
    93419104                        r_alloc_ivt_fsm = ALLOC_IVT_READ;
     
    93439106                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_IVT_LOCK)
    93449107                        r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
    9345 
    9346                     else
    9347                         m_cpt_ivt_unused++;
    93489108                }
    93499109                break;
     
    93629122                        r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
    93639123
    9364                     else if((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
     9124                    else if ((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
    93659125                            (r_read_fsm.read() == READ_IVT_UPDT_LOCK))
    93669126                        r_alloc_ivt_fsm = ALLOC_IVT_READ;
     
    93729132                             (r_cleanup_fsm.read() == CLEANUP_LOCKED_IVT_LOCK))
    93739133                        r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
    9374 
    9375                     else
    9376                         m_cpt_ivt_unused++;
    93779134                }
    93789135                break;
     
    93889145                        r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
    93899146
    9390                     else if((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
     9147                    else if ((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
    93919148                            (r_read_fsm.read() == READ_IVT_UPDT_LOCK))
    93929149                        r_alloc_ivt_fsm = ALLOC_IVT_READ;
     
    94019158                    else if (r_cas_fsm.read() == CAS_INVAL_IVT_LOCK)
    94029159                        r_alloc_ivt_fsm = ALLOC_IVT_CAS;
    9403 
    9404                     else
    9405                         m_cpt_ivt_unused++;
    94069160                }
    94079161                break;
     
    94179171                        r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
    94189172
    9419                     else if((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
     9173                    else if ((r_read_fsm.read() == READ_IVT_INVAL_LOCK) or
    94209174                            (r_read_fsm.read() == READ_IVT_UPDT_LOCK))
    94219175                        r_alloc_ivt_fsm = ALLOC_IVT_READ;
     
    94339187                    else if (r_config_fsm.read() == CONFIG_IVT_LOCK)
    94349188                        r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
    9435 
    9436                     else
    9437                         m_cpt_ivt_unused++;
    94389189                }
    94399190                break;
     
    94599210                r_alloc_dir_reset_cpt.write(r_alloc_dir_reset_cpt.read() + 1);
    94609211
    9461                 if(r_alloc_dir_reset_cpt.read() == (m_sets - 1))
     9212                if (r_alloc_dir_reset_cpt.read() == (m_sets - 1))
    94629213                {
    94639214                    m_cache_directory.init();
     
    94689219                //////////////////////
    94699220            case ALLOC_DIR_CONFIG:    // allocated to CONFIG FSM
    9470                 if ( (r_config_fsm.read()    != CONFIG_DIR_REQ) and
     9221                if ((r_config_fsm.read()    != CONFIG_DIR_REQ) and
    94719222                     (r_config_fsm.read()    != CONFIG_DIR_ACCESS) and
    94729223                     (r_config_fsm.read()    != CONFIG_TRT_LOCK) and
     
    94749225                     (r_config_fsm.read()    != CONFIG_IVT_LOCK) )
    94759226                {
    9476                     if(r_read_fsm.read() == READ_DIR_REQ)
     9227                    if (r_read_fsm.read() == READ_DIR_REQ)
    94779228                        r_alloc_dir_fsm = ALLOC_DIR_READ;
    94789229
    9479                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
     9230                    else if (r_write_fsm.read() == WRITE_DIR_REQ)
    94809231                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    94819232
    9482                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
     9233                    else if (r_cas_fsm.read() == CAS_DIR_REQ)
    94839234                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    94849235
    9485                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     9236                    else if (r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    94869237                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    94879238
    9488                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     9239                    else if (r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    94899240                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    94909241
    9491                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     9242                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    94929243                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    9493 
    9494                     else
    9495                         m_cpt_dir_unused++;
    9496  
    94979244                }
    94989245                break;
     
    95009247                ////////////////////
    95019248            case ALLOC_DIR_READ:    // allocated to READ FSM
    9502                 if( ((r_read_fsm.read()      != READ_DIR_REQ)   and
     9249                if (((r_read_fsm.read()      != READ_DIR_REQ)   and
    95039250                     (r_read_fsm.read()      != READ_DIR_LOCK)   and
    95049251                     (r_read_fsm.read()      != READ_TRT_LOCK)   and
     
    95119258                     (r_alloc_trt_fsm.read()  == ALLOC_TRT_READ)) )
    95129259                {
    9513                     if(r_write_fsm.read() == WRITE_DIR_REQ)
     9260                    if (r_write_fsm.read() == WRITE_DIR_REQ)
    95149261                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    95159262
    9516                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
     9263                    else if (r_cas_fsm.read() == CAS_DIR_REQ)
    95179264                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    95189265
    9519                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     9266                    else if (r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    95209267                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    95219268
    9522                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     9269                    else if (r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    95239270                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    95249271
    9525                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     9272                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    95269273                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    95279274
    9528                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     9275                    else if (r_config_fsm.read() == CONFIG_DIR_REQ)
    95299276                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    9530 
    9531                     else
    9532                         m_cpt_dir_unused++;
    9533                 }
    9534                 else
    9535                     m_cpt_read_fsm_dir_used++;
     9277                }
    95369278                break;
    95379279
    95389280                /////////////////////
    95399281            case ALLOC_DIR_WRITE:
    9540                 if(((r_write_fsm.read()       != WRITE_DIR_REQ)  and
     9282                if (((r_write_fsm.read()       != WRITE_DIR_REQ)  and
    95419283                    (r_write_fsm.read()       != WRITE_DIR_LOCK)  and
    95429284                    (r_write_fsm.read()       != WRITE_DIR_HIT)  and
     
    95529294                     (r_alloc_trt_fsm.read()  == ALLOC_TRT_WRITE)))
    95539295                {
    9554                     if(r_cas_fsm.read() == CAS_DIR_REQ)
     9296                    if (r_cas_fsm.read() == CAS_DIR_REQ)
    95559297                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    95569298
    9557                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     9299                    else if (r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    95589300                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    95599301
    9560                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     9302                    else if (r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    95619303                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    95629304
    9563                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     9305                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    95649306                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    95659307
    9566                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     9308                    else if (r_config_fsm.read() == CONFIG_DIR_REQ)
    95679309                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    95689310
    9569                     else if(r_read_fsm.read() == READ_DIR_REQ)
     9311                    else if (r_read_fsm.read() == READ_DIR_REQ)
    95709312                        r_alloc_dir_fsm = ALLOC_DIR_READ;
    9571 
    9572                     else
    9573                         m_cpt_dir_unused++;
    9574                 }
    9575                 else
    9576                     m_cpt_write_fsm_dir_used++;
     9313                }
    95779314                break;
    95789315
    95799316                ///////////////////
    95809317            case ALLOC_DIR_CAS:    // allocated to CAS FSM
    9581                 if(((r_cas_fsm.read()         != CAS_DIR_REQ)  and
     9318                if (((r_cas_fsm.read()         != CAS_DIR_REQ)  and
    95829319                    (r_cas_fsm.read()         != CAS_DIR_LOCK)  and
    95839320                    (r_cas_fsm.read()         != CAS_DIR_HIT_READ)  and
     
    95949331                     (r_alloc_trt_fsm.read()  == ALLOC_TRT_CAS)))
    95959332                {                   
    9596                     if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     9333                    if (r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    95979334                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    95989335
    9599                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     9336                    else if (r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    96009337                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    96019338
    9602                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     9339                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    96039340                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    96049341
    9605                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     9342                    else if (r_config_fsm.read() == CONFIG_DIR_REQ)
    96069343                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    96079344
    9608                     else if(r_read_fsm.read() == READ_DIR_REQ)
     9345                    else if (r_read_fsm.read() == READ_DIR_REQ)
    96099346                        r_alloc_dir_fsm = ALLOC_DIR_READ;
    96109347
    9611                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
     9348                    else if (r_write_fsm.read() == WRITE_DIR_REQ)
    96129349                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    9613 
    9614                     else
    9615                         m_cpt_dir_unused++;
    9616                 }
    9617                 else
    9618                     m_cpt_cas_fsm_dir_used++;
     9350                }
    96199351                break;
    96209352                ////////////////////////
    96219353            case ALLOC_DIR_MULTI_ACK:    // allocated to MULTI_ACK FSM
    9622                 if(((r_multi_ack_fsm.read() != MULTI_ACK_DIR_REQ) and
     9354                if (((r_multi_ack_fsm.read() != MULTI_ACK_DIR_REQ) and
    96239355                    (r_multi_ack_fsm.read() != MULTI_ACK_DIR_LOCK) and
    96249356                    (r_multi_ack_fsm.read() != MULTI_ACK_IVT_LOCK) and
     
    96319363                 //    (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK)))
    96329364                {
    9633                     if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     9365                    if (r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    96349366                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    96359367
    9636                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     9368                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    96379369                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    96389370
    9639                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     9371                    else if (r_config_fsm.read() == CONFIG_DIR_REQ)
    96409372                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    96419373
    9642                     else if(r_read_fsm.read() == READ_DIR_REQ)
     9374                    else if (r_read_fsm.read() == READ_DIR_REQ)
    96439375                        r_alloc_dir_fsm = ALLOC_DIR_READ;
    96449376
    9645                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
     9377                    else if (r_write_fsm.read() == WRITE_DIR_REQ)
    96469378                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    96479379
    9648                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
     9380                    else if (r_cas_fsm.read() == CAS_DIR_REQ)
    96499381                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    9650 
    9651                     else
    9652                         m_cpt_dir_unused++;
    9653                 }
    9654                 else
    9655                     m_cpt_multi_ack_fsm_dir_used++;
     9382                }
    96569383                break;
    96579384                ///////////////////////
    96589385            case ALLOC_DIR_CLEANUP:    // allocated to CLEANUP FSM
    9659                 if((r_cleanup_fsm.read() != CLEANUP_DIR_REQ) and
     9386                if ((r_cleanup_fsm.read() != CLEANUP_DIR_REQ) and
    96609387                   (r_cleanup_fsm.read() != CLEANUP_DIR_LOCK) and
    96619388                   (r_cleanup_fsm.read() != CLEANUP_LOCKED_IVT_LOCK) and
     
    96649391                   (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK))
    96659392                {
    9666                     if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     9393                    if (r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    96679394                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    96689395
    9669                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     9396                    else if (r_config_fsm.read() == CONFIG_DIR_REQ)
    96709397                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    96719398
    9672                     else if(r_read_fsm.read() == READ_DIR_REQ)
     9399                    else if (r_read_fsm.read() == READ_DIR_REQ)
    96739400                        r_alloc_dir_fsm = ALLOC_DIR_READ;
    96749401
    9675                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
     9402                    else if (r_write_fsm.read() == WRITE_DIR_REQ)
    96769403                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    96779404
    9678                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
     9405                    else if (r_cas_fsm.read() == CAS_DIR_REQ)
    96799406                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    96809407
    9681                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     9408                    else if (r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    96829409                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    9683 
    9684                     else
    9685                         m_cpt_dir_unused++;
    9686                 }
    9687                 else
    9688                     m_cpt_cleanup_fsm_dir_used++;
     9410                }
    96899411                break;
    96909412
    96919413                ////////////////////////
    96929414            case ALLOC_DIR_XRAM_RSP:    // allocated to XRAM_RSP FSM
    9693                 if( (r_xram_rsp_fsm.read() != XRAM_RSP_DIR_LOCK) and
     9415                if ((r_xram_rsp_fsm.read() != XRAM_RSP_DIR_LOCK) and
    96949416                    (r_xram_rsp_fsm.read() != XRAM_RSP_TRT_COPY) and
    96959417                    (r_xram_rsp_fsm.read() != XRAM_RSP_IVT_LOCK))
    96969418                {
    9697                     if(r_config_fsm.read() == CONFIG_DIR_REQ)
     9419                    if (r_config_fsm.read() == CONFIG_DIR_REQ)
    96989420                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    96999421
    9700                     else if(r_read_fsm.read() == READ_DIR_REQ)
     9422                    else if (r_read_fsm.read() == READ_DIR_REQ)
    97019423                        r_alloc_dir_fsm = ALLOC_DIR_READ;
    97029424
    9703                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
     9425                    else if (r_write_fsm.read() == WRITE_DIR_REQ)
    97049426                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    97059427
    9706                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
     9428                    else if (r_cas_fsm.read() == CAS_DIR_REQ)
    97079429                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    97089430
    9709                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     9431                    else if (r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    97109432                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    97119433
    9712                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     9434                    else if (r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    97139435                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    9714 
    9715                     else
    9716                         m_cpt_dir_unused++;
    9717                 }
    9718                 else
    9719                     m_cpt_xram_rsp_fsm_dir_used++;
     9436                }
    97209437                break;
    97219438
     
    97359452            ////////////////////
    97369453            case ALLOC_TRT_READ:
    9737                 if(r_read_fsm.read() != READ_TRT_LOCK)
    9738                 {
    9739                     if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9454                if (r_read_fsm.read() != READ_TRT_LOCK)
     9455                {
     9456                    if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    97409457                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    97419458
    9742                     else if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9459                    else if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    97439460                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    97449461
    9745                     else if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9462                    else if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    97469463                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    97479464                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    97519468                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    97529469
    9753                     else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     9470                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    97549471                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    97559472                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    97569473
    9757                     else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
     9474                    else if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    97589475                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    97599476                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    97609477
    9761                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9478                    else if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    97629479                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    97639480
    97649481                    else if (r_cleanup_fsm.read() == CLEANUP_MISS_IXR_REQ)
    97659482                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    9766 
    9767                     else
    9768                         m_cpt_trt_unused++;
    9769                 }
    9770                 else
    9771                     m_cpt_read_fsm_trt_used++;
     9483                }
    97729484                break;
    97739485
    97749486                /////////////////////
    97759487            case ALLOC_TRT_WRITE:
    9776                 if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
     9488                if ((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
    97779489                   (r_write_fsm.read() != WRITE_INVAL_IVT_LOCK))
    97789490                {
    9779                     if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9491                    if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    97809492                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    97819493
    9782                     else if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9494                    else if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    97839495                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    97849496                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    97889500                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    97899501
    9790                     else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     9502                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    97919503                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    97929504                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    97939505
    9794                     else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
     9506                    else if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    97959507                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    97969508                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    97979509
    9798                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9510                    else if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    97999511                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    98009512
     
    98029514                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    98039515
    9804                     else if(r_read_fsm.read() == READ_TRT_LOCK)
     9516                    else if (r_read_fsm.read() == READ_TRT_LOCK)
    98059517                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    9806 
    9807                     else
    9808                         m_cpt_trt_unused++;
    9809                 }
    9810                 else
    9811                     m_cpt_write_fsm_trt_used++;
     9518                }
    98129519                break;
    98139520
    98149521                ////////////////////
    98159522            case ALLOC_TRT_CAS:
    9816                 if(r_cas_fsm.read() != CAS_MISS_TRT_LOCK)
    9817                 {
    9818                     if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9523                if (r_cas_fsm.read() != CAS_MISS_TRT_LOCK)
     9524                {
     9525                    if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    98199526                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    98209527                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    98249531                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    98259532
    9826                     else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     9533                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    98279534                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    98289535                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    98299536
    9830                     else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
     9537                    else if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    98319538                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    98329539                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    98339540
    9834                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9541                    else if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    98359542                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    98369543
     
    98389545                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    98399546
    9840                     else if(r_read_fsm.read() == READ_TRT_LOCK)
     9547                    else if (r_read_fsm.read() == READ_TRT_LOCK)
    98419548                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    98429549
    9843                     else if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9550                    else if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    98449551                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    9845 
    9846                     else
    9847                         m_cpt_trt_unused++;
    9848                 }
    9849                 else
    9850                     m_cpt_cas_fsm_trt_used++;
     9552                }
    98519553                break;
    98529554                ///////////////////////
    98539555            case ALLOC_TRT_IXR_CMD:
    9854                 if((r_ixr_cmd_fsm.read() != IXR_CMD_READ_TRT) and
     9556                if ((r_ixr_cmd_fsm.read() != IXR_CMD_READ_TRT) and
    98559557                        (r_ixr_cmd_fsm.read() != IXR_CMD_WRITE_TRT) and
    98569558                        (r_ixr_cmd_fsm.read() != IXR_CMD_CAS_TRT) and
     
    98599561                        (r_ixr_cmd_fsm.read() != IXR_CMD_CONFIG_TRT))
    98609562                {
    9861                     if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     9563                    if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    98629564                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    98639565                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    98649566
    9865                     else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
     9567                    else if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    98669568                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    98679569                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    98689570
    9869                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9571                    else if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    98709572                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    98719573
     
    98739575                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    98749576
    9875                     else if(r_read_fsm.read() == READ_TRT_LOCK)
     9577                    else if (r_read_fsm.read() == READ_TRT_LOCK)
    98769578                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    98779579
    9878                     else if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9580                    else if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    98799581                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    98809582
    9881                     else if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9583                    else if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    98829584                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    9883 
    9884                     else
    9885                         m_cpt_trt_unused++;
    9886                        
    9887                 }
    9888                 else
    9889                     m_cpt_ixr_cmd_fsm_trt_used++;
    9890                    
     9585                }
    98919586                break;
    98929587
    98939588                ////////////////////////
    98949589            case ALLOC_TRT_XRAM_RSP:
    9895                 if(((r_xram_rsp_fsm.read()  != XRAM_RSP_DIR_LOCK)  or
     9590                if (((r_xram_rsp_fsm.read()  != XRAM_RSP_DIR_LOCK)  or
    98969591                            (r_alloc_dir_fsm.read() != ALLOC_DIR_XRAM_RSP)) and
    98979592                        (r_xram_rsp_fsm.read()  != XRAM_RSP_TRT_COPY)  and
     
    98999594                        (r_xram_rsp_fsm.read()  != XRAM_RSP_IVT_LOCK))
    99009595                {
    9901                     if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
     9596                    if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    99029597                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    99039598                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    99049599
    9905                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9600                    else if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    99069601                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    99079602
     
    99099604                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    99109605
    9911                     else if(r_read_fsm.read() == READ_TRT_LOCK)
     9606                    else if (r_read_fsm.read() == READ_TRT_LOCK)
    99129607                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    99139608
    9914                     else if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9609                    else if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    99159610                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    99169611
    9917                     else if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9612                    else if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    99189613                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    99199614
    9920                     else if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9615                    else if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    99219616                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    99229617                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    99259620                            (r_ixr_cmd_fsm.read() == IXR_CMD_CONFIG_TRT) )
    99269621                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    9927 
    9928                     else
    9929                         m_cpt_trt_unused++;
    9930                 }
    9931                 else
    9932                     m_cpt_xram_rsp_fsm_trt_used++;
     9622                }
    99339623                break;
    99349624
    99359625                ////////////////////////
    99369626            case ALLOC_TRT_IXR_RSP:
    9937                 if((r_ixr_rsp_fsm.read() != IXR_RSP_TRT_ERASE) and
     9627                if ((r_ixr_rsp_fsm.read() != IXR_RSP_TRT_ERASE) and
    99389628                        (r_ixr_rsp_fsm.read() != IXR_RSP_TRT_READ))
    99399629                {
    9940                     if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9630                    if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    99419631                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    99429632
     
    99449634                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    99459635
    9946                     else if(r_read_fsm.read() == READ_TRT_LOCK)
     9636                    else if (r_read_fsm.read() == READ_TRT_LOCK)
    99479637                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    99489638
    9949                     else if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9639                    else if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    99509640                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    99519641
    9952                     else if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9642                    else if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    99539643                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    99549644
    9955                     else if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9645                    else if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    99569646                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    99579647                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    99619651                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    99629652
    9963                     else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) &&
     9653                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) &&
    99649654                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    99659655                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    9966 
    9967                     else
    9968                         m_cpt_trt_unused++;
    9969                 }
    9970                 else
    9971                     m_cpt_ixr_rsp_fsm_trt_used++;
     9656                }
    99729657                break;
    99739658
    99749659                //////////////////////
    99759660            case ALLOC_TRT_CONFIG:
    9976                 if((r_config_fsm.read() != CONFIG_TRT_LOCK) and
     9661                if ((r_config_fsm.read() != CONFIG_TRT_LOCK) and
    99779662                        (r_config_fsm.read() != CONFIG_TRT_SET))
    99789663                {
     
    99809665                        r_alloc_trt_fsm = ALLOC_TRT_CLEANUP;
    99819666
    9982                     else if(r_read_fsm.read() == READ_TRT_LOCK)
     9667                    else if (r_read_fsm.read() == READ_TRT_LOCK)
    99839668                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    99849669
    9985                     else if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9670                    else if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    99869671                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    99879672
    9988                     else if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9673                    else if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    99899674                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    99909675
    9991                     else if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9676                    else if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    99929677                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    99939678                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    99979682                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    99989683
    9999                     else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     9684                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    100009685                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    100019686                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    100029687
    10003                     else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
     9688                    else if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    100049689                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    100059690                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
     
    100099694                ////////////////////////
    100109695            case ALLOC_TRT_CLEANUP:
    10011                 if(r_cleanup_fsm.read() != CLEANUP_MISS_IXR_REQ)
    10012                 {
    10013                     if(r_read_fsm.read() == READ_TRT_LOCK)
     9696                if (r_cleanup_fsm.read() != CLEANUP_MISS_IXR_REQ)
     9697                {
     9698                    if (r_read_fsm.read() == READ_TRT_LOCK)
    100149699                        r_alloc_trt_fsm = ALLOC_TRT_READ;
    100159700
    10016                     else if(r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
     9701                    else if (r_write_fsm.read() == WRITE_MISS_TRT_LOCK)
    100179702                        r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    100189703
    10019                     else if(r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
     9704                    else if (r_cas_fsm.read() == CAS_MISS_TRT_LOCK)
    100209705                        r_alloc_trt_fsm = ALLOC_TRT_CAS;
    100219706
    10022                     else if((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
     9707                    else if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_TRT) or
    100239708                            (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_TRT) or
    100249709                            (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_TRT) or
     
    100289713                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    100299714
    10030                     else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     9715                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    100319716                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    100329717                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    100339718
    10034                     else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
     9719                    else if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
    100359720                            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    100369721                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    100379722
    10038                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
     9723                    else if (r_config_fsm.read() == CONFIG_TRT_LOCK )
    100399724                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    10040    
    10041                     else
    10042                         m_cpt_trt_unused ++;
    10043                 }
    10044                 else
    10045                     m_cpt_cleanup_fsm_trt_used++;
     9725                }
    100469726                break;
    100479727
     
    100669746                r_alloc_heap_reset_cpt.write(r_alloc_heap_reset_cpt.read() + 1);
    100679747
    10068                 if(r_alloc_heap_reset_cpt.read() == (m_heap_size-1))
     9748                if (r_alloc_heap_reset_cpt.read() == (m_heap_size-1))
    100699749                {
    100709750                    m_heap.init();
     
    100769756                ////////////////////
    100779757            case ALLOC_HEAP_READ:
    10078                 if((r_read_fsm.read() != READ_HEAP_REQ) and
     9758                if ((r_read_fsm.read() != READ_HEAP_REQ) and
    100799759                   (r_read_fsm.read() != READ_HEAP_LOCK) and
    100809760                   (r_read_fsm.read() != READ_HEAP_ERASE) and
     
    100829762                   (r_read_fsm.read() != READ_INVAL_HEAP_ERASE))
    100839763                {
    10084                     if(r_write_fsm.read() == WRITE_HEAP_REQ)
     9764                    if (r_write_fsm.read() == WRITE_HEAP_REQ)
    100859765                        r_alloc_heap_fsm = ALLOC_HEAP_WRITE;
    100869766
    10087                     else if(r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
     9767                    else if (r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
    100889768                        r_alloc_heap_fsm = ALLOC_HEAP_CAS;
    100899769
    10090                     else if(r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
     9770                    else if (r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
    100919771                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    100929772               
    10093                     else if(r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
     9773                    else if (r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
    100949774                        r_alloc_heap_fsm = ALLOC_HEAP_MULTI_ACK;
    100959775
    10096                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     9776                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    100979777                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    100989778
    10099                     else if(r_config_fsm.read() == CONFIG_HEAP_REQ)
     9779                    else if (r_config_fsm.read() == CONFIG_HEAP_REQ)
    101009780                        r_alloc_heap_fsm = ALLOC_HEAP_CONFIG;
    101019781
     
    101039783                        m_cpt_heap_unused++;
    101049784                }
    10105                 else
    10106                     m_cpt_read_fsm_heap_used++;
    101079785                break;
    101089786
    101099787                /////////////////////
    101109788            case ALLOC_HEAP_WRITE:
    10111                 if((r_write_fsm.read() != WRITE_HEAP_REQ) and
     9789                if ((r_write_fsm.read() != WRITE_HEAP_REQ) and
    101129790                   (r_write_fsm.read() != WRITE_HEAP_ERASE))
    101139791                {
    10114                     if(r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
     9792                    if (r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
    101159793                        r_alloc_heap_fsm = ALLOC_HEAP_CAS;
    101169794
    10117                     else if(r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
     9795                    else if (r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
    101189796                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    101199797
    10120                     else if(r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
     9798                    else if (r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
    101219799                        r_alloc_heap_fsm = ALLOC_HEAP_MULTI_ACK;
    101229800
    10123                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     9801                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    101249802                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    101259803
    10126                     else if(r_config_fsm.read() == CONFIG_HEAP_REQ)
     9804                    else if (r_config_fsm.read() == CONFIG_HEAP_REQ)
    101279805                        r_alloc_heap_fsm = ALLOC_HEAP_CONFIG;
    101289806
    10129                     else if((r_read_fsm.read() == READ_HEAP_REQ) or
     9807                    else if ((r_read_fsm.read() == READ_HEAP_REQ) or
    101309808                            (r_read_fsm.read() == READ_INVAL_HEAP_REQ))
    101319809                        r_alloc_heap_fsm = ALLOC_HEAP_READ;
     
    101349812                        m_cpt_heap_unused++;
    101359813                }
    10136                 else
    10137                     m_cpt_write_fsm_heap_used++;
    101389814                break;
    101399815
    101409816                ////////////////////
    101419817            case ALLOC_HEAP_CAS:
    10142                 if((r_cas_fsm.read() != CAS_MULTI_INVAL_HEAP_LOCK) and
     9818                if ((r_cas_fsm.read() != CAS_MULTI_INVAL_HEAP_LOCK) and
    101439819                        (r_cas_fsm.read() != CAS_MULTI_INVAL_REQ) and
    101449820                        (r_cas_fsm.read() != CAS_HEAP_NEXT))
    101459821                {
    10146                     if(r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
     9822                    if (r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
    101479823                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    101489824
    10149                     else if(r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
     9825                    else if (r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
    101509826                        r_alloc_heap_fsm = ALLOC_HEAP_MULTI_ACK;
    101519827
    10152                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     9828                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    101539829                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    101549830
    10155                     else if(r_config_fsm.read() == CONFIG_HEAP_REQ)
     9831                    else if (r_config_fsm.read() == CONFIG_HEAP_REQ)
    101569832                        r_alloc_heap_fsm = ALLOC_HEAP_CONFIG;
    101579833
    10158                     else if((r_read_fsm.read() == READ_HEAP_REQ) or
     9834                    else if ((r_read_fsm.read() == READ_HEAP_REQ) or
    101599835                            (r_read_fsm.read() == READ_INVAL_HEAP_REQ))
    101609836                        r_alloc_heap_fsm = ALLOC_HEAP_READ;
    101619837
    10162                     else if(r_write_fsm.read() == WRITE_HEAP_REQ)
     9838                    else if (r_write_fsm.read() == WRITE_HEAP_REQ)
    101639839                        r_alloc_heap_fsm = ALLOC_HEAP_WRITE;
    101649840
     
    101669842                        m_cpt_heap_unused++;
    101679843                }
    10168                 else
    10169                     m_cpt_cas_fsm_heap_used++;
    101709844                break;
    101719845
    101729846                ///////////////////////
    101739847            case ALLOC_HEAP_CLEANUP:
    10174                 if((r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) and
     9848                if ((r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) and
    101759849                        (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK) and
    101769850                        (r_cleanup_fsm.read() != CLEANUP_HEAP_SEARCH) and
    101779851                        (r_cleanup_fsm.read() != CLEANUP_HEAP_CLEAN))
    101789852                {
    10179                     if(r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
     9853                    if (r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
    101809854                        r_alloc_heap_fsm = ALLOC_HEAP_MULTI_ACK;
    101819855
    10182                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     9856                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    101839857                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    101849858
    10185                     else if(r_config_fsm.read() == CONFIG_HEAP_REQ)
     9859                    else if (r_config_fsm.read() == CONFIG_HEAP_REQ)
    101869860                        r_alloc_heap_fsm = ALLOC_HEAP_CONFIG;
    101879861
    10188                     else if((r_read_fsm.read() == READ_HEAP_REQ) or
     9862                    else if ((r_read_fsm.read() == READ_HEAP_REQ) or
    101899863                            (r_read_fsm.read() == READ_INVAL_HEAP_REQ))
    101909864                        r_alloc_heap_fsm = ALLOC_HEAP_READ;
    101919865
    10192                     else if(r_write_fsm.read() == WRITE_HEAP_REQ)
     9866                    else if (r_write_fsm.read() == WRITE_HEAP_REQ)
    101939867                        r_alloc_heap_fsm = ALLOC_HEAP_WRITE;
    101949868
    10195                     else if(r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
     9869                    else if (r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
    101969870                        r_alloc_heap_fsm = ALLOC_HEAP_CAS;
    101979871
     
    101999873                        m_cpt_heap_unused++;
    102009874                }
    10201                 else
    10202                     m_cpt_cleanup_fsm_heap_used++;
    102039875                break;
    102049876
    102059877                ////////////////////////
    102069878             case ALLOC_HEAP_MULTI_ACK:
    10207                 if((r_multi_ack_fsm.read() != MULTI_ACK_HEAP_REQ) and
     9879                if ((r_multi_ack_fsm.read() != MULTI_ACK_HEAP_REQ) and
    102089880                        (r_multi_ack_fsm.read() != MULTI_ACK_HEAP_LOCK))
    102099881                {
    10210                     if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     9882                    if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    102119883                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    102129884
    10213                     else if(r_config_fsm.read() == CONFIG_HEAP_REQ)
     9885                    else if (r_config_fsm.read() == CONFIG_HEAP_REQ)
    102149886                        r_alloc_heap_fsm = ALLOC_HEAP_CONFIG;
    102159887
    10216                     else if((r_read_fsm.read() == READ_HEAP_REQ) or
     9888                    else if ((r_read_fsm.read() == READ_HEAP_REQ) or
    102179889                            (r_read_fsm.read() == READ_INVAL_HEAP_REQ))
    102189890                        r_alloc_heap_fsm = ALLOC_HEAP_READ;
    102199891
    10220                     else if(r_write_fsm.read() == WRITE_HEAP_REQ)
     9892                    else if (r_write_fsm.read() == WRITE_HEAP_REQ)
    102219893                        r_alloc_heap_fsm = ALLOC_HEAP_WRITE;
    102229894
    10223                     else if(r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
     9895                    else if (r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
    102249896                        r_alloc_heap_fsm = ALLOC_HEAP_CAS;
    102259897
    10226                     else if(r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
     9898                    else if (r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
    102279899                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    102289900
     
    102309902                        m_cpt_heap_unused++;
    102319903                }
    10232                 else
    10233                     m_cpt_multi_ack_fsm_heap_used++;
    102349904                break;
    102359905
    102369906                ////////////////////////
    102379907            case ALLOC_HEAP_XRAM_RSP:
    10238                 if((r_xram_rsp_fsm.read() != XRAM_RSP_HEAP_REQ) and
     9908                if ((r_xram_rsp_fsm.read() != XRAM_RSP_HEAP_REQ) and
    102399909                        (r_xram_rsp_fsm.read() != XRAM_RSP_HEAP_ERASE))
    102409910                {
    10241                     if(r_config_fsm.read() == CONFIG_HEAP_REQ)
     9911                    if (r_config_fsm.read() == CONFIG_HEAP_REQ)
    102429912                        r_alloc_heap_fsm = ALLOC_HEAP_CONFIG;
    102439913
    10244                     else if((r_read_fsm.read() == READ_HEAP_REQ) or
     9914                    else if ((r_read_fsm.read() == READ_HEAP_REQ) or
    102459915                            (r_read_fsm.read() == READ_INVAL_HEAP_REQ))
    102469916                        r_alloc_heap_fsm = ALLOC_HEAP_READ;
    102479917
    10248                     else if(r_write_fsm.read() == WRITE_HEAP_REQ)
     9918                    else if (r_write_fsm.read() == WRITE_HEAP_REQ)
    102499919                        r_alloc_heap_fsm = ALLOC_HEAP_WRITE;
    102509920
    10251                     else if(r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
     9921                    else if (r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
    102529922                        r_alloc_heap_fsm = ALLOC_HEAP_CAS;
    102539923
    10254                     else if(r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
     9924                    else if (r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
    102559925                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    102569926
    10257                     else if(r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
     9927                    else if (r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
    102589928                        r_alloc_heap_fsm = ALLOC_HEAP_MULTI_ACK;
    102599929
    102609930                    else
    102619931                        m_cpt_heap_unused++;
    10262 
    102639932                }
    102649933                break;
     
    102669935                ///////////////////////
    102679936            case ALLOC_HEAP_CONFIG:
    10268                 if((r_config_fsm.read() != CONFIG_HEAP_REQ) and
     9937                if ((r_config_fsm.read() != CONFIG_HEAP_REQ) and
    102699938                        (r_config_fsm.read() != CONFIG_HEAP_SCAN))
    102709939                {
    10271                     if((r_read_fsm.read() == READ_HEAP_REQ) or
     9940                    if ((r_read_fsm.read() == READ_HEAP_REQ) or
    102729941                            (r_read_fsm.read() == READ_INVAL_HEAP_REQ))
    102739942                        r_alloc_heap_fsm = ALLOC_HEAP_READ;
    102749943
    10275                     else if(r_write_fsm.read() == WRITE_HEAP_REQ)
     9944                    else if (r_write_fsm.read() == WRITE_HEAP_REQ)
    102769945                        r_alloc_heap_fsm = ALLOC_HEAP_WRITE;
    102779946
    10278                     else if(r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
     9947                    else if (r_cas_fsm.read() == CAS_MULTI_INVAL_HEAP_LOCK)
    102799948                        r_alloc_heap_fsm = ALLOC_HEAP_CAS;
    102809949
    10281                     else if(r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
     9950                    else if (r_cleanup_fsm.read() == CLEANUP_HEAP_REQ)
    102829951                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    102839952
    10284                     else if(r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
     9953                    else if (r_multi_ack_fsm.read() == MULTI_ACK_HEAP_REQ)
    102859954                        r_alloc_heap_fsm = ALLOC_HEAP_MULTI_ACK;
    102869955
    10287                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     9956                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    102889957                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    102899958                    else
    102909959                        m_cpt_heap_unused++;
    102919960                }
    10292                 else
    10293                     m_cpt_xram_rsp_fsm_heap_used++;
    102949961                break;
    102959962
     
    1035110018        ////////////////////////////////////////////////////////////////////////////////////
    1035210019
    10353         if(cc_receive_to_cleanup_fifo_put)
     10020        if (cc_receive_to_cleanup_fifo_put)
    1035410021        {
    10355             if(cc_receive_to_cleanup_fifo_get)
     10022            if (cc_receive_to_cleanup_fifo_get)
    1035610023            {
    1035710024                m_cc_receive_to_cleanup_fifo.put_and_get( ((uint64_t)(p_dspin_p2m.eop.read()&0x1) << 32) | p_dspin_p2m.data.read() );
     
    1036410031        else
    1036510032        {
    10366             if(cc_receive_to_cleanup_fifo_get)
     10033            if (cc_receive_to_cleanup_fifo_get)
    1036710034            {
    1036810035                m_cc_receive_to_cleanup_fifo.simple_get();
     
    1037710044        ////////////////////////////////////////////////////////////////////////////////////
    1037810045
    10379         if(cc_receive_to_multi_ack_fifo_put)
     10046        if (cc_receive_to_multi_ack_fifo_put)
    1038010047        {
    10381             if(cc_receive_to_multi_ack_fifo_get)
     10048            if (cc_receive_to_multi_ack_fifo_get)
    1038210049            {
    1038310050                m_cc_receive_to_multi_ack_fifo.put_and_get( ((uint64_t)(p_dspin_p2m.eop.read()&0x1) << 32) | p_dspin_p2m.data.read() );
     
    1039010057        else
    1039110058        {
    10392             if(cc_receive_to_multi_ack_fifo_get)
     10059            if (cc_receive_to_multi_ack_fifo_get)
    1039310060            {
    1039410061                m_cc_receive_to_multi_ack_fifo.simple_get();
     
    1044610113        // The three sources of (increment / decrement) are CONFIG / CLEANUP / IXR_RSP FSMs
    1044710114        ////////////////////////////////////////////////////////////////////////////////////
    10448         if ( config_rsp_lines_incr and not
     10115        if (config_rsp_lines_incr and not
    1044910116             (config_rsp_lines_cleanup_decr or config_rsp_lines_ixr_rsp_decr) )
    1045010117        {
    1045110118            r_config_rsp_lines = r_config_rsp_lines.read() + 1;
    1045210119        }
    10453         if ( not config_rsp_lines_incr and 
     10120        if (not config_rsp_lines_incr and 
    1045410121             (config_rsp_lines_cleanup_decr or config_rsp_lines_ixr_rsp_decr) )
    1045510122        {
     
    1046210129//                                r_debug_data);
    1046310130//#if DEBUG_MEMC_MULTI_ACK
    10464 //                    if(m_debug)
     10131//                    if (m_debug)
    1046510132//                        std::cout << "  <MEMC " << name() << " DEBUG DATA>"
    1046610133//                            << " / data0  = "  << r_debug_data[0].read()
     
    1052210189        p_vci_ixr.cfixed  = false;
    1052310190
    10524         if ( (r_ixr_cmd_fsm.read() == IXR_CMD_READ_SEND) or
     10191        if ((r_ixr_cmd_fsm.read() == IXR_CMD_READ_SEND) or
    1052510192                (r_ixr_cmd_fsm.read() == IXR_CMD_WRITE_SEND) or
    1052610193                (r_ixr_cmd_fsm.read() == IXR_CMD_CAS_SEND) or
     
    1053010197            p_vci_ixr.cmdval    = true;
    1053110198
    10532             if ( r_ixr_cmd_get.read() )  // GET
     10199            if (r_ixr_cmd_get.read() )  // GET
    1053310200            {
    1053410201                p_vci_ixr.cmd     = vci_param_ext::CMD_READ;
     
    1056710234        ////////////////////////////////////////////////////
    1056810235
    10569         if( (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ) or
     10236        if ((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ) or
    1057010237                (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) )
    1057110238        {
     
    1066710334                    p_vci_tgt.rspval  = true;
    1066810335
    10669                     if ( is_ll and not r_tgt_rsp_key_sent.read() )
     10336                    if (is_ll and not r_tgt_rsp_key_sent.read() )
    1067010337                    {
    1067110338                        // LL response first flit
     
    1068910356                {
    1069010357                    p_vci_tgt.rspval   = true;
    10691                     if(((r_write_to_tgt_rsp_pktid.read() & 0x7) == TYPE_SC) and r_write_to_tgt_rsp_sc_fail.read())
     10358                    if (((r_write_to_tgt_rsp_pktid.read() & 0x7) == TYPE_SC) and r_write_to_tgt_rsp_sc_fail.read())
    1069210359                        p_vci_tgt.rdata  = 1;
    1069310360                    else
     
    1071110378                        p_vci_tgt.rdata   = r_cleanup_to_tgt_rsp_ll_key.read();
    1071210379                    }
    10713                     else if ( not r_cleanup_to_tgt_rsp_type.read())
     10380                    else if (not r_cleanup_to_tgt_rsp_type.read())
    1071410381                    {
    1071510382                        p_vci_tgt.rdata    = r_cleanup_to_tgt_rsp_data[r_tgt_rsp_cpt.read()].read();
     
    1074810415                    p_vci_tgt.rspval  = true;
    1074910416
    10750                     if( is_ll and not r_tgt_rsp_key_sent.read() )
     10417                    if (is_ll and not r_tgt_rsp_key_sent.read() )
    1075110418                    {
    1075210419                        // LL response first flit
     
    1077810445                    p_vci_tgt.rspval   = true;
    1077910446
    10780                     if(is_ll and not r_tgt_rsp_key_sent.read())
     10447                    if (is_ll and not r_tgt_rsp_key_sent.read())
    1078110448                    {
    1078210449                        p_vci_tgt.rdata = r_cleanup_to_tgt_rsp_ll_key.read();
     
    1081810485                {
    1081910486                    uint8_t multi_inval_type;
    10820                     if(m_config_to_cc_send_inst_fifo.read())
    10821                     {
    10822                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     10487                    if (m_config_to_cc_send_inst_fifo.read())
     10488                    {
     10489                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_INST;
    1082310490                    }
    1082410491                    else
    1082510492                    {
    10826                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
     10493                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_DATA;
    1082710494                    }
    1082810495
    1082910496                    uint64_t flit = 0;
    1083010497                    uint64_t dest = m_config_to_cc_send_srcid_fifo.read() <<
    10831                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    10832 
    10833                     DspinDhccpParam::dspin_set( flit,
     10498                        (DspinHmesiParam::SRCID_WIDTH - vci_param_int::S);
     10499
     10500                    DspinHmesiParam::dspin_set( flit,
    1083410501                            dest,
    10835                             DspinDhccpParam::MULTI_INVAL_DEST);
    10836 
    10837                     DspinDhccpParam::dspin_set( flit,
    10838                             m_cc_global_id ,
    10839                             DspinDhccpParam::MULTI_INVAL_SRCID);
     10502                            DspinHmesiParam::MULTI_INVAL_DEST);
    1084010503
    1084110504                    // MODIFIED FOR CONFIG INVAL (solution 1 bit in flit multi_inval)
    10842                     DspinDhccpParam::dspin_set( flit,
     10505                    DspinHmesiParam::dspin_set( flit,
    1084310506                            1,
    10844                             DspinDhccpParam::MULTI_INVAL_IS_CONFIG);
    10845 
    10846                     DspinDhccpParam::dspin_set( flit,
     10507                            DspinHmesiParam::MULTI_INVAL_IS_CONFIG);
     10508
     10509                    DspinHmesiParam::dspin_set( flit,
    1084710510                            r_config_to_cc_send_trdid.read(),
    10848                             DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
    10849 
    10850                     DspinDhccpParam::dspin_set( flit,
     10511                            DspinHmesiParam::MULTI_INVAL_UPDT_INDEX);
     10512
     10513                    DspinHmesiParam::dspin_set( flit,
    1085110514                            multi_inval_type,
    10852                             DspinDhccpParam::M2P_TYPE);
     10515                            DspinHmesiParam::M2P_TYPE);
    1085310516                    p_dspin_m2p.write = true;
    1085410517                    p_dspin_m2p.data  = flit;
     
    1085910522                {
    1086010523                    uint64_t flit = 0;
    10861                     DspinDhccpParam::dspin_set( flit,
     10524                    DspinHmesiParam::dspin_set( flit,
    1086210525                            r_config_to_cc_send_nline.read(),
    10863                             DspinDhccpParam::MULTI_INVAL_NLINE);
     10526                            DspinHmesiParam::MULTI_INVAL_NLINE);
    1086410527                    p_dspin_m2p.eop   = true;
    1086510528                    p_dspin_m2p.write = true;
     
    1087010533            case CC_SEND_XRAM_RSP_INVAL_HEADER:
    1087110534                {
    10872                     if(not m_xram_rsp_to_cc_send_inst_fifo.rok()) break;
     10535                    if (not m_xram_rsp_to_cc_send_inst_fifo.rok()) break;
    1087310536
    1087410537                    uint8_t multi_inval_type;
    10875                     if(m_xram_rsp_to_cc_send_inst_fifo.read())
    10876                     {
    10877                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     10538                    if (m_xram_rsp_to_cc_send_inst_fifo.read())
     10539                    {
     10540                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_INST;
    1087810541                    }
    1087910542                    else
    1088010543                    {
    10881                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
     10544                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_DATA;
    1088210545                    }
    1088310546
    1088410547                    uint64_t flit = 0;
    1088510548                    uint64_t dest = m_xram_rsp_to_cc_send_srcid_fifo.read() <<
    10886                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    10887 
    10888                     DspinDhccpParam::dspin_set( flit,
     10549                        (DspinHmesiParam::SRCID_WIDTH - vci_param_int::S);
     10550
     10551                    DspinHmesiParam::dspin_set( flit,
    1088910552                            dest,
    10890                             DspinDhccpParam::MULTI_INVAL_DEST);
    10891 
    10892                     DspinDhccpParam::dspin_set( flit,
    10893                             m_cc_global_id ,
    10894                             DspinDhccpParam::MULTI_INVAL_SRCID);
    10895 
    10896                     DspinDhccpParam::dspin_set( flit,
     10553                            DspinHmesiParam::MULTI_INVAL_DEST);
     10554
     10555                    DspinHmesiParam::dspin_set( flit,
    1089710556                            r_xram_rsp_to_cc_send_trdid.read(),
    10898                             DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
    10899 
    10900                     DspinDhccpParam::dspin_set( flit,
     10557                            DspinHmesiParam::MULTI_INVAL_UPDT_INDEX);
     10558
     10559                    DspinHmesiParam::dspin_set( flit,
    1090110560                            multi_inval_type,
    10902                             DspinDhccpParam::M2P_TYPE);
     10561                            DspinHmesiParam::M2P_TYPE);
    1090310562                    p_dspin_m2p.write = true;
    1090410563                    p_dspin_m2p.data  = flit;
     
    1091110570                    uint64_t flit = 0;
    1091210571
    10913                     DspinDhccpParam::dspin_set( flit,
     10572                    DspinHmesiParam::dspin_set( flit,
    1091410573                            r_xram_rsp_to_cc_send_nline.read(),
    10915                             DspinDhccpParam::MULTI_INVAL_NLINE);
     10574                            DspinHmesiParam::MULTI_INVAL_NLINE);
    1091610575                    p_dspin_m2p.eop   = true;
    1091710576                    p_dspin_m2p.write = true;
     
    1092510584                    uint64_t flit = 0;
    1092610585
    10927                     DspinDhccpParam::dspin_set( flit,
     10586                    DspinHmesiParam::dspin_set( flit,
    1092810587                            m_broadcast_boundaries,
    10929                             DspinDhccpParam::BROADCAST_BOX);
     10588                            DspinHmesiParam::BROADCAST_BOX);
    1093010589                    // MODIFIED FOR CONFIG INVAL (solution 1 bit in flit multi_inval)
    10931                     DspinDhccpParam::dspin_set( flit,
     10590                    DspinHmesiParam::dspin_set( flit,
    1093210591                            1,
    10933                             DspinDhccpParam::BRDCAST_IS_CONFIG);
    10934 
    10935                     DspinDhccpParam::dspin_set( flit,
    10936                             m_cc_global_id,
    10937                             DspinDhccpParam::BROADCAST_SRCID);
    10938 
    10939                     DspinDhccpParam::dspin_set( flit,
     10592                            DspinHmesiParam::BRDCAST_IS_CONFIG);
     10593
     10594                    DspinHmesiParam::dspin_set( flit,
    1094010595                            1ULL,
    10941                             DspinDhccpParam::M2P_BC);
     10596                            DspinHmesiParam::M2P_BC);
    1094210597                    p_dspin_m2p.write = true;
    1094310598                    p_dspin_m2p.data  = flit;
     
    1095110606                    uint64_t flit = 0;
    1095210607
    10953                     DspinDhccpParam::dspin_set( flit,
     10608                    DspinHmesiParam::dspin_set( flit,
    1095410609                            m_broadcast_boundaries,
    10955                             DspinDhccpParam::BROADCAST_BOX);
    10956 
    10957                     DspinDhccpParam::dspin_set( flit,
    10958                             m_cc_global_id,
    10959                             DspinDhccpParam::BROADCAST_SRCID);
    10960 
    10961                     DspinDhccpParam::dspin_set( flit,
     10610                            DspinHmesiParam::BROADCAST_BOX);
     10611
     10612                    DspinHmesiParam::dspin_set( flit,
    1096210613                            1ULL,
    10963                             DspinDhccpParam::M2P_BC);
     10614                            DspinHmesiParam::M2P_BC);
    1096410615                    p_dspin_m2p.write = true;
    1096510616                    p_dspin_m2p.data  = flit;
     
    1097110622                    uint64_t flit = 0;
    1097210623
    10973                     DspinDhccpParam::dspin_set( flit,
     10624                    DspinHmesiParam::dspin_set( flit,
    1097410625                             m_broadcast_boundaries,
    10975                              DspinDhccpParam::BROADCAST_BOX);
    10976 
    10977                      DspinDhccpParam::dspin_set( flit,
     10626                             DspinHmesiParam::BROADCAST_BOX);
     10627
     10628                     DspinHmesiParam::dspin_set( flit,
    1097810629                             r_read_to_cc_send_srcid.read(),    // send the srcid itself which demands the request getM
    10979                              DspinDhccpParam::BROADCAST_SRCID);
    10980 
    10981                     DspinDhccpParam::dspin_set( flit,
     10630                             DspinHmesiParam::BROADCAST_SRCID);
     10631
     10632                    DspinHmesiParam::dspin_set( flit,
    1098210633                            1ULL,
    10983                             DspinDhccpParam::M2P_BC);
     10634                            DspinHmesiParam::M2P_BC);
    1098410635                    p_dspin_m2p.write = true;
    1098510636                    p_dspin_m2p.data  = flit;
     
    1099010641                {
    1099110642                    uint64_t flit = 0;
    10992                     DspinDhccpParam::dspin_set( flit,
     10643                    DspinHmesiParam::dspin_set( flit,
    1099310644                            r_xram_rsp_to_cc_send_nline.read(),
    10994                             DspinDhccpParam::BROADCAST_NLINE);
     10645                            DspinHmesiParam::BROADCAST_NLINE);
    1099510646                    p_dspin_m2p.write = true;
    1099610647                    p_dspin_m2p.eop   = true;
     
    1100210653                {
    1100310654                    uint64_t flit = 0;
    11004                     DspinDhccpParam::dspin_set( flit,
     10655                    DspinHmesiParam::dspin_set( flit,
    1100510656                            r_config_to_cc_send_nline.read(),
    11006                             DspinDhccpParam::BROADCAST_NLINE);
     10657                            DspinHmesiParam::BROADCAST_NLINE);
    1100710658                    p_dspin_m2p.write = true;
    1100810659                    p_dspin_m2p.eop   = true;
     
    1101410665                {
    1101510666                    uint64_t flit = 0;
    11016                     DspinDhccpParam::dspin_set( flit,
     10667                    DspinHmesiParam::dspin_set( flit,
    1101710668                            r_read_to_cc_send_nline.read(),
    11018                             DspinDhccpParam::BROADCAST_NLINE);
     10669                            DspinHmesiParam::BROADCAST_NLINE);
    1101910670                    p_dspin_m2p.write = true;
    1102010671                    p_dspin_m2p.eop   = true;
     
    1102710678                    uint64_t flit = 0;
    1102810679
    11029                     if(not m_read_to_cc_send_inst_fifo.rok()) break;
     10680                    if (not m_read_to_cc_send_inst_fifo.rok()) break;
    1103010681                    uint8_t multi_inval_type;
    1103110682
    1103210683                    uint64_t dest =
    1103310684                        m_read_to_cc_send_srcid_fifo.read() <<
    11034                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
     10685                        (DspinHmesiParam::SRCID_WIDTH - vci_param_int::S);
    1103510686
    1103610687                    if (m_read_to_cc_send_inst_fifo.read())
    1103710688                    {
    11038                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     10689                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_INST;
    1103910690                    }
    1104010691                    else
    1104110692                    {
    11042                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
    11043                     }
    11044 
    11045                     DspinDhccpParam::dspin_set(
     10693                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_DATA;
     10694                    }
     10695
     10696                    DspinHmesiParam::dspin_set(
    1104610697                            flit,
    1104710698                            dest,
    11048                             DspinDhccpParam::MULTI_INVAL_DEST);
    11049 
    11050                     DspinDhccpParam::dspin_set(
     10699                            DspinHmesiParam::MULTI_INVAL_DEST);
     10700
     10701                    DspinHmesiParam::dspin_set(
    1105110702                            flit,
    1105210703                            r_read_to_cc_send_is_shared.read(),
    11053                             DspinDhccpParam::MULTI_INVAL_IS_SHARED);
    11054 
    11055                     if(r_read_to_cc_send_type.read())
    11056                     {
    11057                         DspinDhccpParam::dspin_set(
     10704                            DspinHmesiParam::MULTI_INVAL_IS_SHARED);
     10705
     10706                    if (r_read_to_cc_send_type.read())
     10707                    {
     10708                        DspinHmesiParam::dspin_set(
    1105810709                                flit,
    1105910710                                multi_inval_type,
    11060                                 DspinDhccpParam::M2P_TYPE);
     10711                                DspinHmesiParam::M2P_TYPE);
    1106110712                    }
    1106210713                    else
    1106310714                    {
    11064                         DspinDhccpParam::dspin_set(
     10715                        DspinHmesiParam::dspin_set(
    1106510716                                flit,
    11066                                 DspinDhccpParam::TYPE_MULTI_UPDT_DATA,
    11067                                 DspinDhccpParam::M2P_TYPE);
    11068 
    11069                         DspinDhccpParam::dspin_set(
     10717                                DspinHmesiParam::TYPE_MULTI_UPDT_DATA,
     10718                                DspinHmesiParam::M2P_TYPE);
     10719
     10720                        DspinHmesiParam::dspin_set(
    1107010721                                flit,
    1107110722                                r_read_to_cc_send_ivt_index.read(),
    11072                                 DspinDhccpParam::CC_UPDT_IVT_INDEX);
     10723                                DspinHmesiParam::CC_UPDT_IVT_INDEX);
    1107310724
    1107410725                    }
     
    1108410735                    uint64_t flit = 0;
    1108510736
    11086                     DspinDhccpParam::dspin_set(
     10737                    DspinHmesiParam::dspin_set(
    1108710738                            flit,
    1108810739                            r_read_to_cc_send_nline.read(),
    11089                             DspinDhccpParam::MULTI_INVAL_NLINE);
     10740                            DspinHmesiParam::MULTI_INVAL_NLINE);
    1109010741
    1109110742
     
    1110110752                {
    1110210753                    uint64_t flit = 0;
    11103                     DspinDhccpParam::dspin_set( flit,
     10754                    DspinHmesiParam::dspin_set( flit,
    1110410755                            r_write_to_cc_send_nline.read(),
    11105                             DspinDhccpParam::BROADCAST_NLINE);
     10756                            DspinHmesiParam::BROADCAST_NLINE);
    1110610757                    p_dspin_m2p.write = true;
    1110710758                    p_dspin_m2p.eop   = true;
     
    1111310764                {
    1111410765                    uint64_t flit = 0;
    11115                     DspinDhccpParam::dspin_set( flit,
     10766                    DspinHmesiParam::dspin_set( flit,
    1111610767                            r_cas_to_cc_send_nline.read(),
    11117                             DspinDhccpParam::BROADCAST_NLINE);
     10768                            DspinHmesiParam::BROADCAST_NLINE);
    1111810769                    p_dspin_m2p.write = true;
    1111910770                    p_dspin_m2p.eop   = true;
     
    1112410775            case CC_SEND_WRITE_INVAL_HEADER:
    1112510776                {
    11126                     if(not m_write_to_cc_send_inst_fifo.rok()) break;
     10777                    if (not m_write_to_cc_send_inst_fifo.rok()) break;
    1112710778
    1112810779                    uint8_t multi_inval_type;
    11129                     if(m_write_to_cc_send_inst_fifo.read())
    11130                     {
    11131                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     10780                    if (m_write_to_cc_send_inst_fifo.read())
     10781                    {
     10782                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_INST;
    1113210783                    }
    1113310784                    else
    1113410785                    {
    11135                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
     10786                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_DATA;
    1113610787                    }
    1113710788
     
    1113910790                    uint64_t dest =
    1114010791                        m_write_to_cc_send_srcid_fifo.read() <<
    11141                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    11142 
    11143                     DspinDhccpParam::dspin_set(
     10792                        (DspinHmesiParam::SRCID_WIDTH - vci_param_int::S);
     10793
     10794                    DspinHmesiParam::dspin_set(
    1114410795                            flit,
    1114510796                            dest,
    11146                             DspinDhccpParam::MULTI_INVAL_DEST);
    11147 
    11148                     DspinDhccpParam::dspin_set(
    11149                             flit,
    11150                             m_cc_global_id,
    11151                             DspinDhccpParam::MULTI_INVAL_SRCID);
    11152 
    11153                     DspinDhccpParam::dspin_set(
     10797                            DspinHmesiParam::MULTI_INVAL_DEST);
     10798
     10799                    DspinHmesiParam::dspin_set(
    1115410800                            flit,
    1115510801                            multi_inval_type,
    11156                             DspinDhccpParam::M2P_TYPE);
     10802                            DspinHmesiParam::M2P_TYPE);
    1115710803
    1115810804                    p_dspin_m2p.write = true;
     
    1116610812                    uint64_t flit = 0;
    1116710813
    11168                     DspinDhccpParam::dspin_set(
     10814                    DspinHmesiParam::dspin_set(
    1116910815                            flit,
    1117010816                            r_write_to_cc_send_nline.read(),
    11171                             DspinDhccpParam::MULTI_UPDT_NLINE);
     10817                            DspinHmesiParam::MULTI_UPDT_NLINE);
    1117210818
    1117310819                    p_dspin_m2p.write = true;
     
    1118410830
    1118510831                    uint8_t multi_inval_type;
    11186                     if(m_cas_to_cc_send_inst_fifo.read())
    11187                     {
    11188                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     10832                    if (m_cas_to_cc_send_inst_fifo.read())
     10833                    {
     10834                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_INST;
    1118910835                    }
    1119010836                    else
    1119110837                    {
    11192                         multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
     10838                        multi_inval_type = DspinHmesiParam::TYPE_MULTI_INVAL_DATA;
    1119310839                    }
    1119410840
     
    1119610842                    uint64_t dest =
    1119710843                        m_cas_to_cc_send_srcid_fifo.read() <<
    11198                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    11199 
    11200                     DspinDhccpParam::dspin_set(
     10844                        (DspinHmesiParam::SRCID_WIDTH - vci_param_int::S);
     10845
     10846                    DspinHmesiParam::dspin_set(
    1120110847                            flit,
    1120210848                            dest,
    11203                             DspinDhccpParam::MULTI_UPDT_DEST);
    11204 
    11205                     DspinDhccpParam::dspin_set(
    11206                             flit,
    11207                             m_cc_global_id,
    11208                             DspinDhccpParam::MULTI_UPDT_SRCID);
    11209 
    11210                     DspinDhccpParam::dspin_set(
     10849                            DspinHmesiParam::MULTI_UPDT_DEST);
     10850
     10851                    DspinHmesiParam::dspin_set(
    1121110852                            flit,
    1121210853                            multi_inval_type,
    11213                             DspinDhccpParam::M2P_TYPE);
     10854                            DspinHmesiParam::M2P_TYPE);
    1121410855
    1121510856                    p_dspin_m2p.write = true;
     
    1122310864                    uint64_t flit = 0;
    1122410865
    11225                     DspinDhccpParam::dspin_set(
     10866                    DspinHmesiParam::dspin_set(
    1122610867                            flit,
    1122710868                            r_cas_to_cc_send_nline.read(),
    11228                             DspinDhccpParam::MULTI_UPDT_NLINE);
     10869                            DspinHmesiParam::MULTI_UPDT_NLINE);
    1122910870
    1123010871                    p_dspin_m2p.write = true;
     
    1124010881        ////////////////////////////////////////////////////////////////////
    1124110882
    11242         if ( r_cleanup_fsm.read() == CLEANUP_SEND_CLACK )
     10883        if (r_cleanup_fsm.read() == CLEANUP_SEND_CLACK)
    1124310884        {
    1124410885            uint8_t cleanup_ack_type;
    11245             if(r_cleanup_inst.read())
     10886            if (r_cleanup_inst.read())
    1124610887            {
    11247                 cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
     10888                cleanup_ack_type = DspinHmesiParam::TYPE_CLACK_INST;
    1124810889            }
    1124910890            else
    1125010891            {
    11251                 cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
     10892                cleanup_ack_type = DspinHmesiParam::TYPE_CLACK_DATA;
    1125210893            }
    1125310894
    1125410895            uint64_t flit = 0;
    1125510896            uint64_t dest = r_cleanup_srcid.read() <<
    11256                 (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    11257 
    11258             DspinDhccpParam::dspin_set(
     10897                (DspinHmesiParam::SRCID_WIDTH - vci_param_int::S);
     10898
     10899            DspinHmesiParam::dspin_set(
    1125910900                    flit,
    1126010901                    dest,
    11261                     DspinDhccpParam::CLACK_DEST);
    11262 
    11263             DspinDhccpParam::dspin_set(
     10902                    DspinHmesiParam::CLACK_DEST);
     10903
     10904            DspinHmesiParam::dspin_set(
    1126410905                    flit,
    1126510906                    r_cleanup_nline.read() & 0xFFFF,
    11266                     DspinDhccpParam::CLACK_SET);
    11267 
    11268             DspinDhccpParam::dspin_set(
     10907                    DspinHmesiParam::CLACK_SET);
     10908
     10909            DspinHmesiParam::dspin_set(
    1126910910                    flit,
    1127010911                    r_cleanup_way_index.read(),
    11271                     DspinDhccpParam::CLACK_WAY);
    11272 
    11273             DspinDhccpParam::dspin_set(
     10912                    DspinHmesiParam::CLACK_WAY);
     10913
     10914            DspinHmesiParam::dspin_set(
    1127410915                    flit,
    1127510916                    cleanup_ack_type,
    11276                     DspinDhccpParam::CLACK_TYPE);
     10917                    DspinHmesiParam::CLACK_TYPE);
    1127710918
    1127810919            p_dspin_clack.eop   = true;
Note: See TracChangeset for help on using the changeset viewer.