Ignore:
Timestamp:
Oct 4, 2013, 2:34:03 PM (11 years ago)
Author:
haoliu
Message:

ODCCP merge the components with the version 543 in trunk.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/ODCCP/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r543 r544  
    6464    {
    6565        "TGT_CMD_IDLE",
    66         "TGT_CMD_ERROR",
    6766        "TGT_CMD_READ",
    6867        "TGT_CMD_WRITE",
    6968        "TGT_CMD_CAS",
     69        "TGT_CMD_ERROR",
    7070        "TGT_CMD_CONFIG"
    7171    };
    7272    const char *tgt_rsp_fsm_str[] =
    7373    {
    74         "TGT_RSP_CONFIG_IDLE",
    75         "TGT_RSP_TGT_CMD_IDLE",
    7674        "TGT_RSP_READ_IDLE",
    7775        "TGT_RSP_WRITE_IDLE",
    … …  
    8078        "TGT_RSP_MULTI_ACK_IDLE",
    8179        "TGT_RSP_CLEANUP_IDLE",
    82         "TGT_RSP_CONFIG",
    83         "TGT_RSP_TGT_CMD",
     80        "TGT_RSP_CONFIG_IDLE",
     81        "TGT_RSP_TGT_CMD_IDLE",
    8482        "TGT_RSP_READ",
    8583        "TGT_RSP_WRITE",
    … …  
    8785        "TGT_RSP_XRAM",
    8886        "TGT_RSP_MULTI_ACK",
    89         "TGT_RSP_CLEANUP"
     87        "TGT_RSP_CLEANUP",
     88        "TGT_RSP_CONFIG",
     89        "TGT_RSP_TGT_CMD"
    9090    };
    9191    const char *cc_receive_fsm_str[] =
    … …  
    9898    const char *cc_send_fsm_str[] =
    9999    {
    100         "CC_SEND_CONFIG_IDLE",
    101100        "CC_SEND_XRAM_RSP_IDLE",
    102101        "CC_SEND_WRITE_IDLE",
    103102        "CC_SEND_CAS_IDLE",
    104         "CC_SEND_CONFIG_INVAL_HEADER",
    105         "CC_SEND_CONFIG_INVAL_NLINE",
    106         "CC_SEND_CONFIG_BRDCAST_HEADER",
    107         "CC_SEND_CONFIG_BRDCAST_NLINE",
     103        "CC_SEND_CONFIG_IDLE",
    108104        "CC_SEND_XRAM_RSP_BRDCAST_HEADER",
    109105        "CC_SEND_XRAM_RSP_BRDCAST_NLINE",
    … …  
    120116        "CC_SEND_CAS_UPDT_NLINE",
    121117        "CC_SEND_CAS_UPDT_DATA",
    122         "CC_SEND_CAS_UPDT_DATA_HIGH"
     118        "CC_SEND_CAS_UPDT_DATA_HIGH",
     119        "CC_SEND_CONFIG_INVAL_HEADER",
     120        "CC_SEND_CONFIG_INVAL_NLINE",
     121        "CC_SEND_CONFIG_BRDCAST_HEADER",
     122        "CC_SEND_CONFIG_BRDCAST_NLINE"
    123123    };
    124124    const char *multi_ack_fsm_str[] =
    … …  
    282282    {
    283283        "ALLOC_DIR_RESET",
    284         "ALLOC_DIR_CONFIG",
    285284        "ALLOC_DIR_READ",
    286285        "ALLOC_DIR_WRITE",
    287286        "ALLOC_DIR_CAS",
    288287        "ALLOC_DIR_CLEANUP",
    289         "ALLOC_DIR_XRAM_RSP"
     288        "ALLOC_DIR_XRAM_RSP",
     289        "ALLOC_DIR_CONFIG"
    290290    };
    291291    const char *alloc_trt_fsm_str[] =
    … …  
    345345            const IntTab        &tgtid_d,          // global index on direct network
    346346            const size_t        cc_global_id,      // global index on cc network
     347            const size_t        x_width,           // number of x bits in platform
     348            const size_t        y_width,           // number of x bits in platform
    347349            const size_t        nways,             // number of ways per set
    348350            const size_t        nsets,             // number of associative sets
    … …  
    377379        m_words( nwords ),
    378380        m_cc_global_id( cc_global_id ),
     381        m_xwidth(x_width),
     382        m_ywidth(y_width),
    379383        m_debug_start_cycle( debug_start_cycle ),
    380384        m_debug_ok( debug_ok ),
    … …  
    470474        r_alloc_heap_fsm("r_alloc_heap_fsm"),
    471475        r_alloc_heap_reset_cpt("r_alloc_heap_reset_cpt")
     476#if MONITOR_MEMCACHE_FSM == 1
     477        ,
     478        p_read_fsm("p_read_fsm"),
     479        p_write_fsm("p_write_fsm"),
     480        p_xram_rsp_fsm("p_xram_rsp_fsm"),
     481        p_cas_fsm("p_cas_fsm"),
     482        p_cleanup_fsm("p_cleanup_fsm"),
     483        p_config_fsm("p_config_fsm"),
     484        p_alloc_heap_fsm("p_alloc_heap_fsm"),
     485        p_alloc_dir_fsm("p_alloc_dir_fsm"),
     486        p_alloc_trt_fsm("p_alloc_trt_fsm"),
     487        p_alloc_upt_fsm("p_alloc_upt_fsm"),
     488        p_alloc_ivt_fsm("p_alloc_ivt_fsm"),
     489        p_tgt_cmd_fsm("p_tgt_cmd_fsm"),
     490        p_tgt_rsp_fsm("p_tgt_rsp_fsm"),
     491        p_ixr_cmd_fsm("p_ixr_cmd_fsm"),
     492        p_ixr_rsp_fsm("p_ixr_rsp_fsm"),
     493        p_cc_send_fsm("p_cc_send_fsm"),
     494        p_cc_receive_fsm("p_cc_receive_fsm"),
     495        p_multi_ack_fsm("p_multi_ack_fsm")
     496#endif
    472497        {
    473498            std::cout << "  - Building VciMemCache : " << name << std::endl;
    … …  
    623648    }
    624649
     650   
     651    /////////////////////////////////////////////////////
     652    tmpl(uint32_t)::req_distance(uint32_t req_srcid)
     653    /////////////////////////////////////////////////////
     654    {
     655        const uint32_t srcid_width = vci_param_int::S;
     656        uint8_t self_x_srcid = m_cc_global_id >> (srcid_width - m_xwidth);
     657        uint8_t self_y_srcid = (m_cc_global_id >> (srcid_width - m_ywidth)) & ((1 << m_xwidth) - 1);
     658
     659        uint8_t x_srcid = req_srcid >> (srcid_width - m_xwidth);
     660        uint8_t y_srcid = (req_srcid >> (srcid_width - m_ywidth - m_xwidth)) & ((1 << m_xwidth) - 1);
     661        return abs(self_x_srcid - x_srcid) + abs(self_y_srcid - y_srcid);
     662    }
     663
     664
     665    /////////////////////////////////////////////////////
     666    tmpl(bool)::is_local_req(uint32_t req_srcid)
     667    /////////////////////////////////////////////////////
     668    {
     669        return req_distance(req_srcid) == 0;
     670    }
     671
     672
    625673    //////////////////////////////////////////////////
    626674    tmpl(void) ::print_trace()
    … …  
    648696    }
    649697
     698
    650699    /////////////////////////////////////////
    651     tmpl(void) ::clear_stats()
    652         /////////////////////////////////////////
     700    tmpl(void)::print_stats(bool activity_counters = true, bool stats = true)
    653701    {
    654         m_cpt_cycles                  = 0;
    655         m_cpt_read                    = 0;
    656         m_cpt_read_miss               = 0;
    657         m_cpt_write                   = 0;
    658         m_cpt_write_miss              = 0;
    659         m_cpt_write_cells             = 0;
    660         m_cpt_write_dirty             = 0;
    661         m_cpt_update                  = 0;
    662         m_cpt_update_mult             = 0;
    663         m_cpt_inval_brdcast           = 0;
    664         m_cpt_inval                   = 0;
    665         m_cpt_inval_mult              = 0;
    666         m_cpt_cleanup                 = 0;
    667         m_cpt_cleanup_data            = 0;
    668         m_cpt_ll                      = 0;
    669         m_cpt_sc                      = 0;
    670         m_cpt_cas                     = 0;
    671         m_cpt_trt_full                = 0;
    672         m_cpt_trt_rb                  = 0;
    673         m_cpt_dir_unused              = 0;
    674         m_cpt_ivt_unused              = 0;
    675         m_cpt_heap_unused             = 0;
    676         m_cpt_trt_unused              = 0;
    677         m_cpt_read_fsm_n_dir_lock     = 0;
    678         m_cpt_read_fsm_dir_lock       = 0;
    679         m_cpt_read_fsm_dir_used       = 0;
    680         m_cpt_read_fsm_trt_lock       = 0;
    681         m_cpt_read_fsm_heap_lock      = 0;
    682         m_cpt_write_fsm_dir_lock      = 0;
    683         m_cpt_write_fsm_n_dir_lock    = 0;
    684         m_cpt_write_fsm_upt_lock      = 0;
    685         m_cpt_write_fsm_heap_lock     = 0;
    686         m_cpt_write_fsm_dir_used      = 0;
    687         m_cpt_write_fsm_trt_lock      = 0;
    688         m_cpt_cas_fsm_n_dir_lock      = 0;
    689         m_cpt_cas_fsm_dir_lock        = 0;
    690         m_cpt_cas_fsm_upt_lock        = 0;
    691         m_cpt_cas_fsm_heap_lock       = 0;
    692         m_cpt_cas_fsm_trt_lock        = 0;
    693         m_cpt_cas_fsm_dir_used        = 0;
    694         m_cpt_xram_rsp_fsm_n_dir_lock = 0;
    695         m_cpt_xram_rsp_fsm_dir_lock   = 0;
    696         m_cpt_xram_rsp_fsm_trt_lock   = 0;
    697         m_cpt_xram_rsp_fsm_upt_lock   = 0;
    698         m_cpt_xram_rsp_fsm_heap_lock  = 0;
    699         m_cpt_xram_rsp_fsm_dir_used   = 0;
    700         m_cpt_cleanup_fsm_dir_lock    = 0;
    701         m_cpt_cleanup_fsm_n_dir_lock  = 0;
    702         m_cpt_cleanup_fsm_heap_lock   = 0;
    703         m_cpt_cleanup_fsm_upt_lock    = 0;
    704         m_cpt_cleanup_fsm_dir_used    = 0;
    705         m_cpt_ixr_fsm_trt_lock        = 0;
    706         m_cpt_multi_ack_fsm_upt_lock  = 0;
     702        std::cout << "**********************************" << std::dec << std::endl;
     703        std::cout << "*** MEM_CACHE " << name() << std::endl;
     704        std::cout << "**********************************" << std::dec << std::endl;
     705        if (activity_counters) {
     706        std::cout << "----------------------------------" << std::dec << std::endl;
     707            std::cout << "---     Activity Counters      ---" << std::dec << std::endl;
     708            std::cout << "----------------------------------" << std::dec << std::endl;
     709        std::cout
     710                << "[001] NUMBER OF CYCLES          = " << m_cpt_cycles << std::endl
     711                << std::endl
     712                << "[002] LOCAL READ                = " << m_cpt_read_local << std::endl
     713                << "[003] REMOTE READ               = " << m_cpt_read_remote << std::endl
     714                << "[004] READ COST (FLITS * DIST)  = " << m_cpt_read_cost << std::endl
     715                << std::endl
     716                << "[005] LOCAL WRITE               = " << m_cpt_write_local << std::endl
     717                << "[006] REMOTE WRITE              = " << m_cpt_write_remote << std::endl
     718                << "[007] WRITE FLITS LOCAL         = " << m_cpt_write_flits_local << std::endl
     719                << "[008] WRITE FLITS REMOTE        = " << m_cpt_write_flits_remote << std::endl
     720                << "[009] WRITE COST (FLITS * DIST) = " << m_cpt_write_cost << std::endl
     721                << std::endl
     722                << "[010] LOCAL LL                  = " << m_cpt_ll_local << std::endl
     723                << "[011] REMOTE LL                 = " << m_cpt_ll_remote << std::endl
     724                << "[012] LL COST (FLITS * DIST)    = " << m_cpt_ll_cost << std::endl
     725                << std::endl
     726                << "[013] LOCAL SC                  = " << m_cpt_sc_local << std::endl
     727                << "[014] REMOTE SC                 = " << m_cpt_sc_remote << std::endl
     728                << "[015] SC COST (FLITS * DIST)    = " << m_cpt_sc_cost << std::endl
     729                << std::endl
     730                << "[016] LOCAL CAS                 = " << m_cpt_cas_local << std::endl
     731                << "[017] REMOTE CAS                = " << m_cpt_cas_remote << std::endl
     732                << "[018] CAS COST (FLITS * DIST)   = " << m_cpt_cas_cost << std::endl
     733                << std::endl
     734                << "[019] REQUESTS TRIG. UPDATE     = " << m_cpt_update << std::endl
     735                << "[020] LOCAL UPDATE              = " << m_cpt_update_local << std::endl
     736                << "[021] REMOTE UPDATE             = " << m_cpt_update_remote << std::endl
     737                << "[022] UPDT COST (FLITS * DIST)  = " << m_cpt_update_cost << std::endl
     738                << std::endl
     739                << "[023] REQUESTS TRIG. M_INV      = " << m_cpt_m_inval << std::endl
     740                << "[024] LOCAL M_INV               = " << m_cpt_m_inval_local << std::endl
     741                << "[025] REMOTE M_INV              = " << m_cpt_m_inval_remote << std::endl
     742                << "[026] M_INV COST (FLITS * DIST) = " << m_cpt_m_inval_cost << std::endl
     743                << std::endl
     744                << "[027] BROADCAT INVAL            = " << m_cpt_br_inval << std::endl
     745                << std::endl
     746                << "[028] LOCAL CLEANUP             = " << m_cpt_cleanup_local << std::endl
     747                << "[029] REMOTE CLEANUP            = " << m_cpt_cleanup_remote << std::endl
     748                << "[030] CLNUP COST (FLITS * DIST) = " << m_cpt_cleanup_cost << std::endl
     749                << std::endl
     750                << std::endl
     751                << "[031] READ MISS                 = " << m_cpt_read_miss << std::endl
     752                << "[032] WRITE MISS                = " << m_cpt_write_miss << std::endl
     753                << "[033] WRITE DIRTY               = " << m_cpt_write_dirty << std::endl
     754                << "[034] RD BLOCKED BY HIT IN TRT  = " << m_cpt_trt_rb << std::endl
     755                << "[035] TRANS BLOCKED BY FULL TRT = " << m_cpt_trt_full << std::endl
     756                << "[036] PUT (UNIMPLEMENTED)       = " << m_cpt_put << std::endl
     757                << "[037] GET (UNIMPLEMENTED)       = " << m_cpt_get << std::endl
     758                << "[038] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     759                << std::endl;
    707760    }
    708     /////////////////////////////////////////
    709     tmpl(void) ::print_stats()
    710         /////////////////////////////////////////
    711     {
    712         std::cout << "----------------------------------" << std::dec << std::endl;
    713         std::cout
    714             << "MEM_CACHE " << name() << " / Time = " << m_cpt_cycles << std::endl
    715             << "- READ RATE                              = " << (double) m_cpt_read/m_cpt_cycles << std::endl
    716             << "- READ TOTAL                             = " << m_cpt_read << std::endl
    717             << "- READ MISS RATE                         = " << (double) m_cpt_read_miss/m_cpt_read << std::endl
    718             << "- WRITE RATE                             = " << (double) m_cpt_write/m_cpt_cycles << std::endl
    719             << "- WRITE TOTAL                            = " << m_cpt_write << std::endl
    720             << "- WRITE MISS RATE                        = " << (double) m_cpt_write_miss/m_cpt_write << std::endl
    721             << "- WRITE BURST LENGTH                     = " << (double) m_cpt_write_cells/m_cpt_write << std::endl
    722             << "- WRITE BURST TOTAL                      = " << m_cpt_write_cells << std::endl
    723             << "- REQUESTS TRT FULL                      = " << m_cpt_trt_full << std::endl
    724             << "- READ TRT BLOKED HIT                    = " << m_cpt_trt_rb << std::endl
    725             << "- UPDATE RATE                            = " << (double) m_cpt_update/m_cpt_cycles << std::endl
    726             << "- UPDATE ARITY                           = " << (double) m_cpt_update_mult/m_cpt_update << std::endl
    727             << "- INVAL MULTICAST RATE                   = " << (double)(m_cpt_inval-m_cpt_inval_brdcast) /m_cpt_cycles << std::endl
    728             << "- INVAL MULTICAST ARITY                  = " << (double) m_cpt_inval_mult/ (m_cpt_inval-m_cpt_inval_brdcast) << std::endl
    729             << "- INVAL BROADCAST RATE                   = " << (double) m_cpt_inval_brdcast/m_cpt_cycles << std::endl
    730             << "- SAVE DIRTY RATE                        = " << (double) m_cpt_write_dirty/m_cpt_cycles << std::endl
    731             << "- CLEANUP RATE                           = " << (double) m_cpt_cleanup/m_cpt_cycles << std::endl
    732             << "- CLEANUP TOTAL                          = " << (double) m_cpt_cleanup << std::endl
    733             << "- CLEANUP WITH DATA RATE                 = " << (double) m_cpt_cleanup_data/m_cpt_cycles << std::endl
    734             << "- CLEANUP WITH DATA TOTAL                = " << (double) m_cpt_cleanup_data << std::endl
    735             << "- LL RATE                                = " << (double) m_cpt_ll/m_cpt_cycles << std::endl
    736             << "- SC RATE                                = " << (double) m_cpt_sc/m_cpt_cycles << std::endl
    737             << "- CAS RATE                               = " << (double) m_cpt_cas/m_cpt_cycles << std::endl << std::endl;
    738 
    739         /* << "- WAIT DIR LOCK in READ_FSM              = " << (double) m_cpt_read_fsm_dir_lock/m_cpt_read_fsm_n_dir_lock << std::endl
    740            << "- NB CYCLES IN DIR LOCK in READ_FSM      = " << (double) m_cpt_read_fsm_dir_used/m_cpt_read_fsm_n_dir_lock << std::endl
    741            << "- WAIT DIR LOCK in WRITE_FSM             = " << (double) m_cpt_write_fsm_dir_lock/m_cpt_write_fsm_n_dir_lock << std::endl
    742            << "- NB CYCLES IN DIR LOCK in WRITE_FSM     = " << (double) m_cpt_write_fsm_dir_used/m_cpt_write_fsm_n_dir_lock << std::endl
    743            << "- WAIT DIR LOCK in XRAM_FSM              = " << (double) m_cpt_xram_rsp_fsm_dir_lock/m_cpt_xram_rsp_fsm_n_dir_lock << std::endl
    744            << "- NB CYCLES IN DIR LOCK in XRAM_FSM      = " << (double) m_cpt_xram_rsp_fsm_dir_used/m_cpt_xram_rsp_fsm_n_dir_lock << std::endl
    745            << "- WAIT DIR LOCK in CLEANUP_FSM           = " << (double) m_cpt_cleanup_fsm_dir_lock/m_cpt_cleanup_fsm_n_dir_lock << std::endl
    746            << "- NB CYCLES IN DIR LOCK in CLEANUP_FSM   = " << (double) m_cpt_cleanup_fsm_dir_used/m_cpt_cleanup_fsm_n_dir_lock << std::endl
    747            << "- WAIT DIR LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_dir_lock/m_cpt_cas_fsm_n_dir_lock << std::endl
    748            << "- NB CYCLES IN LOCK in CAS_FSM           = " << (double) m_cpt_cas_fsm_dir_used/m_cpt_cas_fsm_n_dir_lock << std::endl
    749            << "- DIR UNUSED RATE                        = " << (double) m_cpt_dir_unused/m_cpt_cycles << std::endl << std::endl
    750 
    751            << "- WAIT TRT LOCK in READ_FSM              = " << (double) m_cpt_read_fsm_trt_lock/m_cpt_read_fsm_n_trt_lock << std::endl
    752            << "- NB CYCLES IN TRT LOCK in READ_FSM      = " << (double) m_cpt_read_fsm_trt_used/m_cpt_read_fsm_n_trt_lock << std::endl
    753            << "- WAIT TRT LOCK in WRITE_FSM             = " << (double) m_cpt_write_fsm_trt_lock/m_cpt_write_fsm_n_trt_lock << std::endl
    754            << "- NB CYCLES IN TRT LOCK in WRITE_FSM     = " << (double) m_cpt_write_fsm_trt_used/m_cpt_write_fsm_n_trt_lock << std::endl
    755            << "- WAIT TRT LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_trt_lock/m_cpt_cas_fsm_n_trt_lock << std::endl
    756            << "- NB CYCLES IN TRT LOCK in CAS_FSM       = " << (double) m_cpt_cas_fsm_trt_used/m_cpt_cas_fsm_n_trt_lock << std::endl
    757            << "- WAIT TRT LOCK in XRAM_FSM              = " << (double) m_cpt_xram_rsp_fsm_trt_lock/m_cpt_xram_rsp_fsm_n_trt_lock << std::endl
    758            << "- NB CYCLES IN TRT LOCK in XRAM_FSM      = " << (double) m_cpt_xram_rsp_fsm_trt_used/m_cpt_xram_rsp_fsm_n_trt_lock << std::endl
    759            << "- WAIT TRT LOCK in IXR_FSM               = " << (double) m_cpt_ixr_fsm_trt_lock/m_cpt_ixr_fsm_n_trt_lock << std::endl
    760            << "- NB CYCLES IN TRT LOCK in IXR_FSM       = " << (double) m_cpt_ixr_fsm_trt_used/m_cpt_ixr_fsm_n_trt_lock << std::endl
    761            << "- TRT UNUSED RATE                        = " << (double) m_cpt_trt_unused/m_cpt_cycles << std::endl << std::endl
    762 
    763            << "- WAIT UPT LOCK in WRITE_FSM             = " << (double) m_cpt_write_fsm_upt_lock/m_cpt_write_fsm_n_upt_lock << std::endl
    764            << "- NB CYCLES IN UPT LOCK in WRITE_FSM     = " << (double) m_cpt_write_fsm_upt_used/m_cpt_write_fsm_n_upt_lock << std::endl
    765            << "- WAIT UPT LOCK in XRAM_FSM              = " << (double) m_cpt_xram_rsp_fsm_upt_lock/m_cpt_xram_rsp_fsm_n_upt_lock << std::endl
    766            << "- NB CYCLES IN UPT LOCK in XRAM_FSM      = " << (double) m_cpt_xram_rsp_fsm_upt_used/m_cpt_xram_rsp_fsm_n_upt_lock << std::endl
    767            << "- WAIT UPT LOCK in MULTIACK_FSM          = " << (double) m_cpt_multi_ack_fsm_upt_lock/m_cpt_multi_ack_fsm_n_upt_lock << std::endl
    768            << "- NB CYCLES IN UPT LOCK in MULTIACK_FSM  = " << (double) m_cpt_multi_ack_fsm_upt_used/m_cpt_multi_ack_fsm_n_upt_lock << std::endl
    769            << "- WAIT UPT LOCK in CLEANUP_FSM           = " << (double) m_cpt_cleanup_fsm_upt_lock/m_cpt_cleanup_fsm_n_upt_lock << std::endl
    770            << "- NB CYCLES IN UPT LOCK in CLEANUP_FSM   = " << (double) m_cpt_cleanup_fsm_upt_used/m_cpt_cleanup_fsm_n_upt_lock << std::endl
    771            << "- WAIT UPT LOCK in CAS_FSM               = " << (double) m_cpt_cas_fsm_upt_lock/m_cpt_cas_fsm_n_upt_lock << std::endl
    772            << "- NB CYCLES IN UPT LOCK in CAS_FSM       = " << (double) m_cpt_cas_fsm_upt_used/m_cpt_cas_fsm_n_upt_lock << std::endl
    773            << "- IVT UNUSED RATE                        = " << (double) m_cpt_ivt_unused/m_cpt_cycles << std::endl << std::endl
    774 
    775            << "- WAIT HEAP LOCK in READ_FSM             = " << (double) m_cpt_read_fsm_heap_lock/m_cpt_read_fsm_n_heap_lock << std::endl
    776            << "- NB CYCLES IN HEAP LOCK in READ_FSM     = " << (double) m_cpt_read_fsm_heap_used/m_cpt_read_fsm_n_heap_lock << std::endl
    777            << "- WAIT HEAP LOCK in WRITE_FSM            = " << (double) m_cpt_write_fsm_heap_lock/m_cpt_write_fsm_n_heap_lock << std::endl
    778            << "- NB CYCLES IN HEAP LOCK in WRITE_FSM    = " << (double) m_cpt_write_fsm_heap_used/m_cpt_write_fsm_n_heap_lock << std::endl
    779            << "- WAIT HEAP LOCK in XRAM_FSM             = " << (double) m_cpt_xram_rsp_fsm_heap_lock/m_cpt_xram_rsp_fsm_n_heap_lock << std::endl
    780            << "- NB CYCLES IN HEAP LOCK in XRAM_FSM     = " << (double) m_cpt_xram_rsp_fsm_heap_used/m_cpt_xram_rsp_fsm_n_heap_lock << std::endl
    781            << "- WAIT HEAP LOCK in CLEANUP_FSM          = " << (double) m_cpt_cleanup_fsm_heap_lock/m_cpt_cleanup_fsm_n_heap_lock << std::endl
    782            << "- NB CYCLES IN HEAP LOCK in CLEANUP_FSM  = " << (double) m_cpt_cleanup_fsm_heap_used/m_cpt_cleanup_fsm_n_heap_lock << std::endl
    783            << "- WAIT HEAP LOCK in CAS_FSM              = " << (double) m_cpt_cas_fsm_heap_lock/m_cpt_cas_fsm_n_heap_lock << std::endl
    784            << "- NB CYCLES IN HEAP LOCK in CAS_FSM      = " << (double) m_cpt_cas_fsm_heap_used/m_cpt_cas_fsm_n_heap_lock << std::endl
    785            << "- HEAP UNUSED RATE                       = " << (double) m_cpt_heap_unused/m_cpt_cycles << std::endl;*/
     761
     762        if (stats) {
     763            std::cout << "----------------------------------" << std::dec << std::endl;
     764            std::cout << "---      Calculated Stats      ---" << std::dec << std::endl;
     765            std::cout << "----------------------------------" << std::dec << std::endl;
     766            std::cout
     767                << "[100] READ TOTAL            = " << m_cpt_read_local + m_cpt_read_remote << std::endl
     768                << "[101] READ RATE             = " << (double) (m_cpt_read_local + m_cpt_read_remote) / m_cpt_cycles << std::endl
     769                << "[102] LOCAL READ RATE       = " << (double) m_cpt_read_local / m_cpt_cycles << std::endl
     770                << "[103] REMOTE READ RATE      = " << (double) m_cpt_read_remote / m_cpt_cycles << std::endl
     771                << "[104] READ MISS RATE        = " << (double) m_cpt_read_miss / (m_cpt_read_local + m_cpt_read_remote) << std::endl
     772                << std::endl
     773                << "[105] WRITE TOTAL           = " << m_cpt_write_local + m_cpt_write_remote << std::endl
     774                << "[106] WRITE RATE            = " << (double) (m_cpt_write_local + m_cpt_write_remote) / m_cpt_cycles << std::endl
     775                << "[107] LOCAL WRITE RATE      = " << (double) m_cpt_write_local / m_cpt_cycles << std::endl
     776                << "[108] REMOTE WRITE RATE     = " << (double) m_cpt_write_remote / m_cpt_cycles << std::endl
     777                << "[109] WRITE MISS RATE       = " << (double) m_cpt_write_miss / (m_cpt_write_local + m_cpt_write_remote) << std::endl
     778                << "[110] WRITE BURST TOTAL     = " << m_cpt_write_flits_local + m_cpt_write_flits_remote << std::endl
     779                << "[111] WRITE BURST AVERAGE   = " << (double) (m_cpt_write_flits_local + m_cpt_write_flits_remote) / (m_cpt_write_local + m_cpt_write_remote) << std::endl
     780                << "[112] LOCAL WRITE BURST AV. = " << (double) m_cpt_write_flits_local / (m_cpt_write_local + m_cpt_write_remote) << std::endl
     781                << "[113] REMOTE WRITE BURST AV = " << (double) m_cpt_write_flits_remote / (m_cpt_write_local + m_cpt_write_remote) << std::endl
     782                << std::endl
     783                << "[114] UPDATE RATE                = " << (double) m_cpt_update / m_cpt_cycles << std::endl
     784                << "[115] AV. UPDATE PER UP REQ      = " << (double) (m_cpt_update_local + m_cpt_update_remote) / m_cpt_update << std::endl
     785                << "[116] AV. LOC UPDT PER UP REQ    = " << (double) m_cpt_update_local / m_cpt_update << std::endl
     786                << "[117] AV. REMOTE UPDT PER UP REQ = " << (double) m_cpt_update_remote / m_cpt_update << std::endl
     787                << std::endl
     788                << "[118] INVAL MULTICAST RATE  = " << (double) m_cpt_m_inval / m_cpt_cycles << std::endl
     789                << "[119] AVE. INVAL PER M_INV  = " << (double) (m_cpt_m_inval_local + m_cpt_m_inval_remote) / m_cpt_m_inval << std::endl
     790                << "[120] AV. LOC INV PER M_INV = " << (double) m_cpt_m_inval_local / m_cpt_m_inval << std::endl
     791                << "[121] AV. REM INV PER M_INV = " << (double) m_cpt_m_inval_remote / m_cpt_m_inval << std::endl
     792                << std::endl
     793                << "[122] INVAL BROADCAST RATE  = " << (double) m_cpt_br_inval / m_cpt_cycles << std::endl
     794                << "[123] WRITE DIRTY RATE      = " << (double) m_cpt_write_dirty / m_cpt_cycles << std::endl
     795                << std::endl
     796                << "[124] CLEANUP RATE          = " << (double) (m_cpt_cleanup_local + m_cpt_cleanup_remote) / m_cpt_cycles << std::endl
     797                << "[125] LOCAL CLEANUP RATE    = " << (double) m_cpt_cleanup_local / m_cpt_cycles << std::endl
     798                << "[126] REMOTE CLEANUP RATE   = " << (double) m_cpt_cleanup_remote / m_cpt_cycles << std::endl
     799                << "[127] LL RATE               = " << (double) (m_cpt_ll_local + m_cpt_ll_remote) / m_cpt_cycles << std::endl
     800                << "[128] LOCAL LL RATE         = " << (double) m_cpt_ll_local / m_cpt_cycles << std::endl
     801                << "[129] REMOTE LL RATE        = " << (double) m_cpt_ll_remote / m_cpt_cycles << std::endl
     802                << "[130] SC RATE               = " << (double) (m_cpt_sc_local + m_cpt_sc_remote) / m_cpt_cycles << std::endl
     803                << "[131] LOCAL SC RATE         = " << (double) m_cpt_sc_local / m_cpt_cycles << std::endl
     804                << "[132] REMOTE SC RATE        = " << (double) m_cpt_sc_remote / m_cpt_cycles << std::endl
     805                << "[133] CAS RATE              = " << (double) (m_cpt_cas_local + m_cpt_cas_remote) / m_cpt_cycles << std::endl
     806                << "[134] LOCAL CAS RATE        = " << (double) m_cpt_cas_local / m_cpt_cycles << std::endl
     807                << "[135] REMOTE CAS RATE       = " << (double) m_cpt_cas_remote / m_cpt_cycles << std::endl
     808                << std::endl
     809                << std::endl;
     810        }
    786811    }
     812
    787813
    788814    /////////////////////////////////
    … …  
    790816        /////////////////////////////////
    791817    {
     818        delete [] m_seg;
     819
    792820        delete [] r_ixr_rsp_to_xram_rsp_rok;
    793         //delete [] r_ixr_rsp_to_xram_rsp_no_coherent;
    794 
    795821        delete [] r_xram_rsp_victim_data;
    796822        delete [] r_xram_rsp_to_tgt_rsp_data;
    … …  
    802828        delete [] r_write_be;
    803829        delete [] r_write_to_cc_send_data;
     830        delete [] r_write_to_cc_send_be;
    804831
    805832        delete [] r_cleanup_data;
    806         delete [] r_ixr_cmd_data;
    807833        delete [] r_cleanup_to_ixr_cmd_data;
     834
     835        delete [] r_cas_data;
     836        delete [] r_cas_rdata;
     837
     838        delete [] r_ixr_cmd_wdata;
     839        delete [] m_debug_previous_data;
     840        delete [] m_debug_data;
     841
     842        print_stats();
    808843    }
    809844
    … …  
    821856            r_tgt_cmd_fsm    = TGT_CMD_IDLE;
    822857            r_config_fsm     = CONFIG_IDLE;
    823             r_tgt_rsp_fsm    = TGT_RSP_TGT_CMD_IDLE;
     858            r_tgt_rsp_fsm    = TGT_RSP_READ_IDLE;
    824859            r_cc_send_fsm    = CC_SEND_XRAM_RSP_IDLE;
    825860            r_cc_receive_fsm = CC_RECEIVE_IDLE;
    … …  
    833868            r_alloc_trt_fsm  = ALLOC_TRT_READ;
    834869            r_alloc_upt_fsm  = ALLOC_UPT_WRITE;
    835             r_alloc_ivt_fsm  = ALLOC_IVT_XRAM_RSP;
     870            r_alloc_ivt_fsm  = ALLOC_IVT_WRITE;
    836871            r_ixr_rsp_fsm    = IXR_RSP_IDLE;
    837872            r_xram_rsp_fsm   = XRAM_RSP_IDLE;
    … …  
    951986            // Activity counters
    952987            m_cpt_cycles                  = 0;
    953             m_cpt_read                    = 0;
     988            m_cpt_read_local         = 0;
     989            m_cpt_read_remote        = 0;
     990            m_cpt_read_cost          = 0;
     991            m_cpt_write_local        = 0;
     992            m_cpt_write_remote       = 0;
     993            m_cpt_write_flits_local  = 0;
     994            m_cpt_write_flits_remote = 0;
     995            m_cpt_write_cost         = 0;
     996            m_cpt_ll_local           = 0;
     997            m_cpt_ll_remote          = 0;
     998            m_cpt_ll_cost            = 0;
     999            m_cpt_sc_local           = 0;
     1000            m_cpt_sc_remote          = 0;
     1001            m_cpt_sc_cost            = 0;
     1002            m_cpt_cas_local          = 0;
     1003            m_cpt_cas_remote         = 0;
     1004            m_cpt_cas_cost           = 0;
     1005            m_cpt_update             = 0;
     1006            m_cpt_update_local       = 0;
     1007            m_cpt_update_remote      = 0;
     1008            m_cpt_update_cost        = 0;
     1009            m_cpt_m_inval            = 0;
     1010            m_cpt_m_inval_local      = 0;
     1011            m_cpt_m_inval_remote     = 0;
     1012            m_cpt_m_inval_cost       = 0;
     1013            m_cpt_br_inval           = 0;
     1014            m_cpt_cleanup_local      = 0;
     1015            m_cpt_cleanup_remote     = 0;
     1016            m_cpt_cleanup_cost       = 0;
     1017
    9541018            m_cpt_read_miss               = 0;
    955             m_cpt_write                   = 0;
    9561019            m_cpt_write_miss              = 0;
    957             m_cpt_write_cells             = 0;
    9581020            m_cpt_write_dirty             = 0;
    9591021            m_cpt_update                  = 0;
    … …  
    9671029            m_cpt_sc                      = 0;
    9681030            m_cpt_cas                     = 0;
     1031            m_cpt_write_broadcast         = 0;
     1032            m_cpt_trt_rb                  = 0;
    9691033            m_cpt_trt_full                = 0;
    970             m_cpt_trt_rb                  = 0;
     1034            m_cpt_get                     = 0;
     1035            m_cpt_put                     = 0;
    9711036            m_cpt_dir_unused              = 0;
    9721037            m_cpt_ivt_unused              = 0;
    … …  
    10921157        ////////////////////////////////////////////////////////////////////////////////////
    10931158
    1094         //std::cout << std::endl << "tgt_cmd_fsm" << std::endl;
    10951159
    10961160        switch(r_tgt_cmd_fsm.read())
    … …  
    11141178                    bool        config   = false;
    11151179
    1116                     // register arguments for response (segmentation violation or config)
    1117                     r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
    1118                     r_tgt_cmd_to_tgt_rsp_trdid = p_vci_tgt.trdid.read();
    1119                     r_tgt_cmd_to_tgt_rsp_pktid = p_vci_tgt.pktid.read();
    1120 
    1121                     for(size_t seg_id = 0 ; (seg_id < m_nseg) and not found ; seg_id++)
    1122                     {
    1123                         if( m_seg[seg_id]->contains(address) and
     1180                    for (size_t seg_id = 0; (seg_id < m_nseg) && !found; seg_id++)
     1181                    {
     1182                        if (m_seg[seg_id]->contains(address) &&
    11241183                                m_seg[seg_id]->contains(address + plen - vci_param_int::B) )
    11251184                        {
    … …  
    11291188                    }
    11301189
    1131                     if ( not found )                /////////// out of segment error
     1190                    if (!found)                /////////// out of segment error
    11321191                    {
    11331192                        r_tgt_cmd_fsm   = TGT_CMD_ERROR;
    … …  
    11351194                    else if ( config )              /////////// configuration command
    11361195                    {
    1137                         if ( not p_vci_tgt.eop.read() ) r_tgt_cmd_fsm = TGT_CMD_ERROR;
     1196                        if (!p_vci_tgt.eop.read()) r_tgt_cmd_fsm = TGT_CMD_ERROR;
    11381197                        else                            r_tgt_cmd_fsm = TGT_CMD_CONFIG;
    11391198                    }
    … …  
    12021261                if ( p_vci_tgt.cmdval and p_vci_tgt.eop )
    12031262                {
     1263                    r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
     1264                    r_tgt_cmd_to_tgt_rsp_trdid = p_vci_tgt.trdid.read();
     1265                    r_tgt_cmd_to_tgt_rsp_pktid = p_vci_tgt.pktid.read();
    12041266                    r_tgt_cmd_to_tgt_rsp_req   = true;
    12051267                    r_tgt_cmd_to_tgt_rsp_error = 1;
    … …  
    12391301                        error            = 0;
    12401302                        r_config_lock    = true;
    1241                         if ( rdata == 0 )
    1242                         {
    1243                             r_tgt_cmd_srcid = p_vci_tgt.srcid.read();
    1244                             r_tgt_cmd_trdid = p_vci_tgt.trdid.read();
    1245                             r_tgt_cmd_pktid = p_vci_tgt.pktid.read();
    1246                         }
    1247                     }
     1303                        }
    12481304                    else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)  // release lock
    1249                             and (cell == MEMC_LOCK)
    1250                             and (p_vci_tgt.srcid.read() == r_tgt_cmd_srcid.read()) )
     1305                            and (cell == MEMC_LOCK) )
    12511306                    {
    12521307                        need_rsp         = true;
    … …  
    12551310                    }
    12561311                    else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_lo
    1257                             and (cell == MEMC_ADDR_LO)
    1258                             and (p_vci_tgt.srcid.read() == r_tgt_cmd_srcid.read()) )
     1312                            and (cell == MEMC_ADDR_LO) )
    12591313                    {
    12601314                        assert( ((wdata % (m_words*vci_param_int::B)) == 0) and
    … …  
    12641318                        error            = 0;
    12651319                        r_config_address = (r_config_address.read() & 0xFFFFFFFF00000000LL) |
    1266                             (addr_t)p_vci_tgt.wdata.read();
     1320                            ((addr_t)wdata);
    12671321                    }
    12681322                    else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_hi
    1269                             and (cell == MEMC_ADDR_HI)
    1270                             and (p_vci_tgt.srcid.read() == r_tgt_cmd_srcid.read()) )
     1323                            and (cell == MEMC_ADDR_HI) )
    12711324
    12721325                    {
    … …  
    12741327                        error            = 0;
    12751328                        r_config_address = (r_config_address.read() & 0x00000000FFFFFFFFLL) |
    1276                             ((addr_t)p_vci_tgt.wdata.read())<<32;
     1329                            (((addr_t) wdata) << 32);
    12771330                    }
    12781331                    else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
    1279                             and (cell == MEMC_BUF_LENGTH)
    1280                             and (p_vci_tgt.srcid.read() == r_tgt_cmd_srcid.read()) )
     1332                            and (cell == MEMC_BUF_LENGTH) )
    12811333                    {
    12821334                        need_rsp         = true;
    12831335                        error            = 0;
    1284                         size_t lines = (size_t)(p_vci_tgt.wdata.read()/(m_words<<2));
    1285                         if ( r_config_address.read()%(m_words*4) ) lines++;
     1336                        size_t lines = wdata/(m_words<<2);
     1337                        if ( wdata%(m_words<<2) ) lines++;
    12861338                        r_config_cmd_lines  = lines;
    12871339                        r_config_rsp_lines  = lines;
    12881340                    }
    12891341                    else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set cmd type
    1290                             and (cell == MEMC_CMD_TYPE)
    1291                             and (p_vci_tgt.srcid.read() == r_tgt_cmd_srcid.read()) )
     1342                            and (cell == MEMC_CMD_TYPE) )
    12921343                    {
    12931344                        need_rsp         = false;
    12941345                        error            = 0;
    1295                         r_config_cmd     = p_vci_tgt.wdata.read();
     1346                        r_config_cmd     = wdata;
    12961347
    12971348                        // prepare delayed response from CONFIG FSM
    … …  
    13111362                        if ( r_tgt_cmd_to_tgt_rsp_req.read() ) break;
    13121363
     1364                        r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
     1365                        r_tgt_cmd_to_tgt_rsp_trdid = p_vci_tgt.trdid.read();
     1366                        r_tgt_cmd_to_tgt_rsp_pktid = p_vci_tgt.pktid.read();
    13131367                        r_tgt_cmd_to_tgt_rsp_req   = true;
    13141368                        r_tgt_cmd_to_tgt_rsp_error = error;
    … …  
    13711425#endif
    13721426                    cmd_read_fifo_put = true;
    1373                     if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) m_cpt_ll++;
    1374                     else                                                       m_cpt_read++;
     1427                    // <Activity counters>
     1428                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) {
     1429                        if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_ll_local++;
     1430                        else                                      m_cpt_ll_remote++;
     1431                        m_cpt_ll_cost += req_distance(p_vci_tgt.srcid.read()); // LL on a single word
     1432                    }
     1433                    else {
     1434                        if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_read_local++;
     1435                        else                                      m_cpt_read_remote++;
     1436                        m_cpt_read_cost += m_words * req_distance(p_vci_tgt.srcid.read());
     1437                    }
     1438                    // </Activity counters>
    13751439                    r_tgt_cmd_fsm = TGT_CMD_IDLE;
    13761440                }
    … …  
    13941458#endif
    13951459                    cmd_write_fifo_put = true;
    1396                     if(p_vci_tgt.eop)  r_tgt_cmd_fsm = TGT_CMD_IDLE;
     1460                    // <Activity counters>
     1461                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
     1462                        m_cpt_sc_cost += req_distance(p_vci_tgt.srcid.read());
     1463                }
     1464                    else {
     1465                        if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_flits_local++;
     1466                        else                                      m_cpt_write_flits_remote++;
     1467                        m_cpt_write_cost += req_distance(p_vci_tgt.srcid.read());
     1468                    }
     1469                    // </Activity counters>
     1470
     1471                    if (p_vci_tgt.eop) {
     1472                        // <Activity counters>
     1473                        if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
     1474                            if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_sc_local++;
     1475                            else                                      m_cpt_sc_remote++;
     1476
     1477                        }
     1478                        else {
     1479                            if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_local++;
     1480                            else                                      m_cpt_write_remote++;
     1481                        }
     1482                        // </Activity counters>
     1483                        r_tgt_cmd_fsm = TGT_CMD_IDLE;
     1484                    }
    13971485                }
    13981486                break;
    … …  
    14221510#endif
    14231511                    cmd_cas_fifo_put = true;
    1424                     if(p_vci_tgt.eop) r_tgt_cmd_fsm = TGT_CMD_IDLE;
     1512                    if (p_vci_tgt.eop) {
     1513                        // <Activity counters>
     1514                        if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_cas_local++;
     1515                        else                                      m_cpt_cas_remote++;
     1516                        m_cpt_cas_cost += req_distance(p_vci_tgt.srcid.read());
     1517                        // </Activity counters>
     1518                        r_tgt_cmd_fsm = TGT_CMD_IDLE;
     1519                }
    14251520                }
    14261521                break;
    … …  
    17511846                    DirectoryEntry entry = m_cache_directory.read(r_config_address.read(), way);
    17521847
    1753                     if ( entry.valid and                            // hit & inval command
    1754                             (r_config_cmd.read() == MEMC_CMD_INVAL) )
    1755                     {
    1756                         r_config_dir_way        = way;
    1757                         r_config_dir_copy_inst  = entry.owner.inst;
    1758                         r_config_dir_copy_srcid = entry.owner.srcid;
    1759                         r_config_dir_is_cnt     = entry.is_cnt;
    1760                         r_config_dir_lock       = entry.lock;
    1761                         r_config_dir_count      = entry.count;
    1762                         r_config_dir_ptr        = entry.ptr;
    1763 
     1848                    r_config_dir_way        = way;
     1849                    r_config_dir_copy_inst  = entry.owner.inst;
     1850                    r_config_dir_copy_srcid = entry.owner.srcid;
     1851                    r_config_dir_is_cnt     = entry.is_cnt;
     1852                    r_config_dir_lock       = entry.lock;
     1853                    r_config_dir_count      = entry.count;
     1854                    r_config_dir_ptr        = entry.ptr;
     1855
     1856                    if (entry.valid and                            // hit & inval command
     1857                            (r_config_cmd.read() == MEMC_CMD_INVAL))
     1858                    {
    17641859                        r_config_fsm    = CONFIG_IVT_LOCK;
    17651860                    }
    … …  
    17741869                        r_config_cmd_lines = r_config_cmd_lines.read() - 1;
    17751870                        r_config_rsp_lines = r_config_rsp_lines.read() - 1;
    1776                         r_config_cmd_lines = r_config_cmd_lines.read() - 1;
    17771871                        r_config_address   = r_config_address.read() + (m_words<<2);
    17781872                        r_config_fsm       = CONFIG_LOOP;
    … …  
    18261920                            entry.owner.inst  = r_config_dir_copy_inst.read();
    18271921                            entry.owner.srcid = r_config_dir_copy_srcid.read();
    1828                             m_cache_directory.write( set,
    1829                                     way,
    1830                                     entry );
     1922                            m_cache_directory.write( set, way, entry );
    18311923
    18321924                            r_config_trt_index = index;
    … …  
    18561948                    size_t          way = r_config_dir_way.read();
    18571949                    size_t          set = m_y[r_config_address.read()];
    1858 
    1859                     sc_signal<data_t> config_data[16];
    1860                     m_cache_data.read_line( way,
    1861                             set,
    1862                             config_data );
    1863 
    1864                     // post a PUT request in TRT
    18651950                    std::vector<data_t> data_vector;
    18661951                    data_vector.clear();
    1867                     for(size_t i=0; i<m_words; i++) data_vector.push_back(config_data[i].read());
     1952                    for(size_t word=0; word<m_words; word++)
     1953                    {
     1954                        uint32_t data = m_cache_data.read( way, set, word );
     1955                        data_vector.push_back( data );
     1956                    }
     1957
     1958                    // post the PUT request in TRT
    18681959                    m_trt.set( r_config_trt_index.read(),
    1869                             false,                               // PUT
    1870                             m_nline[r_config_address.read()],    // nline
     1960                            false,                               // PUT transaction
     1961                            m_nline[r_config_address.read()],    // line index
    18711962                            0,                                   // srcid:       unused
    18721963                            0,                                   // trdid:       unused
    … …  
    18751966                            0,                                   // read_length: unused
    18761967                            0,                                   // word_index:  unused
    1877                             std::vector<be_t>(m_words,0xF),                         
    1878                             data_vector);
     1968                            std::vector<be_t>(m_words,0xF),      // byte-enable:     unused
     1969                            data_vector,                         // data to be written
     1970                            0,                                   // ll_key:          unused
     1971                            true );                              // requested by config FSM
     1972                    r_config_fsm = CONFIG_PUT_REQ;
    18791973
    18801974#if DEBUG_MEMC_CONFIG
    … …  
    18871981                }
    18881982                ////////////////////
    1889             case CONFIG_PUT_REQ:       // PUT request to IXR_CMD_FSM
     1983            case CONFIG_PUT_REQ:       // post PUT request to IXR_CMD_FSM
    18901984                {
    18911985                    if ( not r_config_to_ixr_cmd_req.read() )
    … …  
    19011995#if DEBUG_MEMC_CONFIG
    19021996                        if(m_debug)
    1903                             std::cout << "  <MEMC " << name() << " CONFIG_PUT_REQ> PUT request to IXR_CMD_FSM"
     1997                            std::cout << "  <MEMC " << name() << " CONFIG_PUT_REQ> post PUT request to IXR_CMD_FSM"
    19041998                                << " / address = " << std::hex << r_config_address.read() << std::endl;
    19051999#endif
    … …  
    27062800            case WRITE_IDLE:  // copy first word of a write burst in local buffer
    27072801                {
    2708                     if(m_cmd_write_addr_fifo.rok())
    2709                     {
    2710                         if((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC)
    2711                         {
    2712                             m_cpt_sc++;
    2713                         }
    2714                         else
    2715                         {
    2716                             m_cpt_write++;
    2717                             m_cpt_write_cells++;
    2718                         }
     2802                    if (not m_cmd_write_addr_fifo.rok()) break;
    27192803
    27202804                        // consume a word in the FIFO & write it in the local buffer
    … …  
    27242808                        r_write_address     = (addr_t)(m_cmd_write_addr_fifo.read());
    27252809                        r_write_word_index  = index;
    2726                         r_write_word_count  = 1;
     2810                    r_write_word_count  = 0;
    27272811                        r_write_data[index] = m_cmd_write_data_fifo.read();
    27282812                        r_write_srcid       = m_cmd_write_srcid_fifo.read();
    27292813                        r_write_trdid       = m_cmd_write_trdid_fifo.read();
    27302814                        r_write_pktid       = m_cmd_write_pktid_fifo.read();
    2731                         r_write_pending_sc  = false;
     2815
     2816                    // if SC command, get the SC key
     2817                    if ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC)
     2818                    {
     2819                        assert( not m_cmd_write_eop_fifo.read() &&
     2820                                "MEMC ERROR in WRITE_IDLE state: "
     2821                                "invalid packet format for SC command");
     2822
     2823                        r_write_sc_key = m_cmd_write_data_fifo.read();
     2824                    }
    27322825
    27332826                        // initialize the be field for all words
    … …  
    27382831                        }
    27392832
    2740                         if (m_cmd_write_eop_fifo.read() or ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC))
     2833                    if (m_cmd_write_eop_fifo.read())
    27412834                        {
    27422835                            r_write_fsm = WRITE_DIR_REQ;
    … …  
    27542847                                << " / data = " << m_cmd_write_data_fifo.read() << std::endl;
    27552848#endif
    2756                     }
    27572849                    break;
    27582850                }
    … …  
    27602852            case WRITE_NEXT:  // copy next word of a write burst in local buffer
    27612853                {
    2762                     if(m_cmd_write_addr_fifo.rok())
    2763                     {
    2764 
    2765 #if DEBUG_MEMC_WRITE
    2766                         if(m_debug)
    2767                             std::cout << "  <MEMC " << name()
    2768                                 << " WRITE_NEXT> Write another word in local buffer"
    2769                                 << std::endl;
    2770 #endif
    2771                         m_cpt_write_cells++;
     2854                    if (not m_cmd_write_addr_fifo.rok()) break;
    27722855
    27732856                        // check that the next word is in the same cache line
    27742857                        assert( (m_nline[(addr_t)(r_write_address.read())] ==
    2775                                     m_nline[(addr_t)(m_cmd_write_addr_fifo.read())]) and
     2858                            m_nline[(addr_t)(m_cmd_write_addr_fifo.read())]) &&
    27762859                                "MEMC ERROR in WRITE_NEXT state: Illegal write burst");
     2860
     2861                    size_t index = m_x[(addr_t)(m_cmd_write_addr_fifo.read())];
     2862                    bool   is_sc = ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC);
     2863
     2864                    // check that SC command has constant address
     2865                    assert((not is_sc or (index == r_write_word_index)) &&
     2866                            "MEMC ERROR in WRITE_NEXT state: "
     2867                            "the address must be constant on a SC command");
     2868
     2869                    // check that SC command has two flits
     2870                    assert((not is_sc or m_cmd_write_eop_fifo.read()) &&
     2871                            "MEMC ERROR in WRITE_NEXT state: "
     2872                            "invalid packet format for SC command");
    27772873
    27782874                        // consume a word in the FIFO & write it in the local buffer
    27792875                        cmd_write_fifo_get  = true;
    2780                         size_t index        = r_write_word_index.read() + r_write_word_count.read();
    27812876
    27822877                        r_write_be[index]   = m_cmd_write_be_fifo.read();
    27832878                        r_write_data[index] = m_cmd_write_data_fifo.read();
     2879
     2880                    // the first flit of a SC command is the reservation key and
     2881                    // therefore it must not be counted as a data to write
     2882                    if (not is_sc)
     2883                    {
    27842884                        r_write_word_count  = r_write_word_count.read() + 1;
     2885                    }
    27852886
    27862887                        if(m_cmd_write_eop_fifo.read()) r_write_fsm = WRITE_DIR_REQ;
    2787                     }
     2888
     2889#if DEBUG_MEMC_WRITE
     2890                    if (m_debug)
     2891                        std::cout << "  <MEMC " << name()
     2892                            << " WRITE_NEXT> Write another word in local buffer"
     2893                            << std::endl;
     2894#endif
    27882895                    break;
    27892896                }
    … …  
    27922899                // and access the llsc_global_table
    27932900                {
    2794                     if( r_alloc_dir_fsm.read() == ALLOC_DIR_WRITE )
    2795                     {
    2796                         if(((r_write_pktid.read() & 0x7) == TYPE_SC) and not r_write_pending_sc.read())
    2797                         {
    2798                             // We enter here if it is a new SC command
    2799                             // If r_write_pending_sc is set the SC is not new and has already been tested
    2800 
    2801                             if(not m_cmd_write_addr_fifo.rok()) break;
    2802 
    2803                             assert( m_cmd_write_eop_fifo.read() and
    2804                                     "MEMC ERROR in WRITE_DIR_REQ state: invalid packet format for SC command");
    2805 
    2806                             size_t index    = r_write_word_index.read();
    2807                             bool sc_success = m_llsc_table.sc(r_write_address.read()    ,
    2808                                     r_write_data[index].read());
    2809 
    2810                             // consume a word in the FIFO & write it in the local buffer
    2811                             cmd_write_fifo_get  = true;
    2812                             r_write_data[index] = m_cmd_write_data_fifo.read();
    2813                             r_write_sc_fail     = not sc_success;
    2814                             r_write_pending_sc  = true;
    2815 
    2816                             if(not sc_success) r_write_fsm = WRITE_RSP;
    2817                             else               r_write_fsm = WRITE_DIR_LOCK;
    2818                         }
    2819                         else
    2820                         {
    2821                             // We enter here if it is a SW command or an already tested SC command
    2822 
     2901                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE ) break;
     2902
     2903                    if ((r_write_pktid.read() & 0x7) == TYPE_SC)
     2904                    {
     2905                        // test address and key match of the SC command on the
     2906                        // LL/SC table without removing reservation. The reservation
     2907                        // will be erased after in this FSM.
     2908                        bool sc_success = m_llsc_table.check(r_write_address.read(),
     2909                                r_write_sc_key.read());
     2910
     2911                        r_write_sc_fail     = not sc_success;
     2912
     2913                        if(not sc_success) r_write_fsm = WRITE_RSP;
     2914                        else               r_write_fsm = WRITE_DIR_LOCK;
     2915                    }
     2916                    else
     2917                    {
     2918                        // write burst
    28232919#define L2 soclib::common::uint32_log2
    2824                             addr_t min = r_write_address.read();
    2825                             addr_t max = r_write_address.read() +
    2826                                 ((r_write_word_count.read()-1) << L2(vci_param_int::B));
     2920                        addr_t min = r_write_address.read();
     2921                        addr_t max = r_write_address.read() +
     2922                            (r_write_word_count.read() << L2(vci_param_int::B));
    28272923#undef L2
    28282924
    2829                             m_llsc_table.sw(min, max);
    2830 
    2831                             r_write_fsm = WRITE_DIR_LOCK;
    2832                         }
     2925                        m_llsc_table.sw(min, max);
     2926
     2927                        r_write_fsm = WRITE_DIR_LOCK;
    28332928                    }
    28342929
    … …  
    29163011                    bool no_update = ( (r_write_count.read() == 0) or
    29173012                            (owner and (r_write_count.read() ==1) and
    2918                              (r_write_pktid.read() != TYPE_SC)));
     3013                             ((r_write_pktid.read() & 0x7) != TYPE_SC)));
    29193014
    29203015                    // write data in the cache if no coherence transaction
    29213016                    if(no_update)
    29223017                    {
     3018                        // SC command but zero copies
     3019                        if ((r_write_pktid.read() & 0x7) == TYPE_SC)
     3020                        {
     3021                            m_llsc_table.sc(r_write_address.read(),
     3022                                            r_write_sc_key.read());
     3023                        }
     3024
    29233025                        for(size_t word=0 ; word<m_words ; word++)
    29243026                        {
    … …  
    29313033                    }
    29323034
    2933                     if(owner and not no_update and(r_write_pktid.read() != TYPE_SC))
     3035                    if (owner and not no_update and ((r_write_pktid.read() & 0x7) != TYPE_SC))
    29343036                    {
    29353037                        r_write_count = r_write_count.read() - 1;
    … …  
    30003102                        if( wok )       // write data in cache
    30013103                        {
     3104                           
     3105                            if ((r_write_pktid.read() & 0x7) == TYPE_SC)
     3106                            {
     3107                                m_llsc_table.sc(r_write_address.read(),
     3108                                                r_write_sc_key.read());
     3109                            }
     3110
    30023111                            for(size_t word=0 ; word<m_words ; word++)
    30033112                            {
    … …  
    30673176                    size_t min = r_write_word_index.read();
    30683177                    size_t max = r_write_word_index.read() + r_write_word_count.read();
    3069                     for(size_t i=min ; i<max ; i++) r_write_to_cc_send_data[i] = r_write_data[i];
     3178                    for(size_t i=min ; i<=max ; i++) r_write_to_cc_send_data[i] = r_write_data[i];
    30703179
    30713180                    if( (r_write_copy.read() != r_write_srcid.read()) or
    3072                             (r_write_pktid.read() == TYPE_SC) or r_write_copy_inst.read())
     3181                       ((r_write_pktid.read() & 0x7) == TYPE_SC)      or
     3182                         r_write_copy_inst.read())
    30733183                    {
    30743184                        // put the first srcid in the fifo
    … …  
    31283238                    // put the next srcid in the fifo
    31293239                    if( (entry.owner.srcid != r_write_srcid.read()) or
    3130                             (r_write_pktid.read() == TYPE_SC) or entry.owner.inst)   
     3240                       ((r_write_pktid.read() & 0x7) == TYPE_SC)    or
     3241                         entry.owner.inst)
    31313242                    {
    31323243                        dec_upt_counter                = false;
    … …  
    32083319                // a new request in the write FIFO
    32093320                {
    3210                     if(!r_write_to_tgt_rsp_req.read())
     3321                    if (not r_write_to_tgt_rsp_req.read())
    32113322                    {
    32123323                        // post the request to TGT_RSP_FSM
    … …  
    32183329
    32193330                        // try to get a new write request from the FIFO
    3220                         if(m_cmd_write_addr_fifo.rok())
    3221                         {
    3222                             if((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC)
    3223                                 m_cpt_sc++;
     3331                        if (not m_cmd_write_addr_fifo.rok())
     3332                        {
     3333                            r_write_fsm = WRITE_IDLE;
     3334                        }
    32243335                            else
    32253336                            {
    3226                                 m_cpt_write++;
    3227                                 m_cpt_write_cells++;
    3228                             }
    3229 
    32303337                            // consume a word in the FIFO & write it in the local buffer
    32313338                            cmd_write_fifo_get  = true;
    … …  
    32343341                            r_write_address     = (addr_t)(m_cmd_write_addr_fifo.read());
    32353342                            r_write_word_index  = index;
    3236                             r_write_word_count  = 1;
     3343                            r_write_word_count  = 0;
    32373344                            r_write_data[index] = m_cmd_write_data_fifo.read();
    32383345                            r_write_srcid       = m_cmd_write_srcid_fifo.read();
    32393346                            r_write_trdid       = m_cmd_write_trdid_fifo.read();
    32403347                            r_write_pktid       = m_cmd_write_pktid_fifo.read();
    3241                             r_write_pending_sc  = false;
     3348
     3349                            // if SC command, get the SC key
     3350                            if ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC)
     3351                            {
     3352                                assert( not m_cmd_write_eop_fifo.read() &&
     3353                                        "MEMC ERROR in WRITE_RSP state: "
     3354                                        "invalid packet format for SC command");
     3355
     3356                                r_write_sc_key = m_cmd_write_data_fifo.read();
     3357                            }
    32423358
    32433359                            // initialize the be field for all words
    … …  
    32483364                            }
    32493365
    3250                             if(m_cmd_write_eop_fifo.read() or ((m_cmd_write_pktid_fifo.read() & 0x7)  == TYPE_SC))
     3366                            if (m_cmd_write_eop_fifo.read())
    32513367                            {
    32523368                                r_write_fsm = WRITE_DIR_REQ;
    … …  
    32563372                                r_write_fsm = WRITE_NEXT;
    32573373                            }
    3258                         }
    3259                         else
    3260                         {
    3261                             r_write_fsm = WRITE_IDLE;
    32623374                        }
    32633375
    … …  
    33023414                        bool    wok       = not m_trt.full(wok_index);
    33033415
    3304                         if(hit_read)      // register the modified data in TRT
     3416                        // wait an empty entry in TRT
     3417                        if(not hit_read and (not wok or hit_write))
     3418                        {
     3419                            r_write_fsm       = WRITE_WAIT;
     3420                            m_cpt_trt_full++;
     3421
     3422                            break;
     3423                        }
     3424
     3425                        if ((r_write_pktid.read() & 0x7) == TYPE_SC)
     3426                        {
     3427                            m_llsc_table.sc(r_write_address.read(),
     3428                                            r_write_sc_key.read());
     3429                        }
     3430
     3431                        // register the modified data in TRT
     3432                        if (hit_read)
    33053433                        {
    33063434                            r_write_trt_index = hit_index;
    33073435                            r_write_fsm       = WRITE_MISS_TRT_DATA;
    33083436                            m_cpt_write_miss++;
    3309                         }
    3310                         else if(wok and !hit_write)      // set a new entry in TRT
     3437                            break;
     3438                        }
     3439
     3440                        // set a new entry in TRT
     3441                        if (wok and not hit_write)
    33113442                        {
    33123443                            r_write_trt_index = wok_index;
    33133444                            r_write_fsm       = WRITE_MISS_TRT_SET;
    33143445                            m_cpt_write_miss++;
    3315                         }
    3316                         else    // wait an empty entry in TRT
    3317                         {
    3318                             r_write_fsm       = WRITE_WAIT;
    3319                             m_cpt_trt_full++;
    3320                         }
    3321                         m_cpt_write_fsm_n_trt_lock++;
    3322                     }
     3446                            break;
     3447                        }
     3448
     3449                        assert(false && "VCI_MEM_CACHE ERROR: this part must not be reached");
     3450                        }
    33233451
    33243452                    m_cpt_write_fsm_trt_lock++;
    … …  
    34063534                    {
    34073535                        r_write_to_ixr_cmd_req   = true;
    3408                         r_write_to_ixr_cmd_put   = false;
    34093536                        r_write_to_ixr_cmd_index = r_write_trt_index.read();
    34103537                        r_write_fsm              = WRITE_RSP;
    … …  
    34123539#if DEBUG_MEMC_WRITE
    34133540                        if(m_debug)
    3414                             std::cout << "  <MEMC " << name() << " WRITE_MISS_XRAM_REQ> Post a GET request to the IXR_CMD FSM" << std::endl;
     3541                            std::cout << "  <MEMC " << name()
     3542                                      << " WRITE_MISS_XRAM_REQ> Post a GET request to the"
     3543                                      << " IXR_CMD FSM" << std::endl;
    34153544#endif
    34163545                    }
    … …  
    34203549            case WRITE_BC_DIR_READ:  // enter this state if a broadcast-inval is required
    34213550                // the cache line must be erased in mem-cache, and written
    3422                 // into XRAM. we read the cache and complete the buffer
     3551                                     // into XRAM.
    34233552                {
    34243553                    assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_WRITE) and
    34253554                            "MEMC ERROR in WRITE_BC_DIR_READ state: Bad DIR allocation");
    34263555
    3427                     // update local buffer
     3556                    m_cpt_write_broadcast++;
     3557
     3558                    // write enable signal for data buffer.
     3559                    r_write_bc_data_we = true;
     3560
     3561                    r_write_fsm = WRITE_BC_TRT_LOCK;
     3562
     3563#if DEBUG_MEMC_WRITE
     3564                    if (m_debug)
     3565                        std::cout << "  <MEMC " << name() << " WRITE_BC_DIR_READ>"
     3566                                  << " Read the cache to complete local buffer" << std::endl;
     3567#endif
     3568                    break;
     3569                }
     3570                ///////////////////////
     3571            case WRITE_BC_TRT_LOCK:     // get TRT lock to check TRT not full
     3572                {
     3573                    assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_WRITE) and
     3574                            "MEMC ERROR in WRITE_BC_TRT_LOCK state: Bad DIR allocation");
     3575
     3576                    // We read the cache and complete the buffer. As the DATA cache uses a
     3577                    // synchronous RAM, the read DATA request has been performed in the
     3578                    // WRITE_BC_DIR_READ state but the data is available in this state.
     3579                    if (r_write_bc_data_we.read())
     3580                    {
    34283581                    size_t set  = m_y[(addr_t)(r_write_address.read())];
    34293582                    size_t way  = r_write_way.read();
    … …  
    34373590
    34383591                        // complete only if mask is not null (for energy consumption)
    3439                         r_write_data[word]  = (r_write_data[word].read() & mask) |
     3592                            r_write_data[word] =
     3593                                (r_write_data[word].read()         &  mask) |
    34403594                            (m_cache_data.read(way, set, word) & ~mask);
    3441                     } // end for
    3442 
    3443                     r_write_fsm = WRITE_BC_TRT_LOCK;
    3444 
     3595                        }
    34453596#if DEBUG_MEMC_WRITE
    34463597                    if(m_debug)
    3447                         std::cout << "  <MEMC " << name() << " WRITE_BC_DIR_READ>"
    3448                             << " Read the cache to complete local buffer" << std::endl;
    3449 #endif
    3450                     break;
    3451                 }
    3452                 ///////////////////////
    3453             case WRITE_BC_TRT_LOCK:     // get TRT lock to check TRT not full
    3454                 {
    3455                     assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_WRITE) and
    3456                             "MEMC ERROR in WRITE_BC_TRT_LOCK state: Bad DIR allocation");
    3457 
    3458                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    3459                     {
     3598                            std::cout
     3599                                << "  <MEMC "  << name()
     3600                                << " WRITE_BC_TRT_LOCK> Complete data buffer" << std::endl;
     3601#endif
     3602                    }
     3603
     3604                    if (r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE)
     3605                    {
     3606                        // if we loop in this state, the data does not need to be
     3607                        // rewritten (for energy consuption)
     3608                        r_write_bc_data_we = false;
     3609                    break;
     3610                }
     3611
    34603612                        size_t wok_index = 0;
    34613613                        bool wok = not m_trt.full(wok_index);
    … …  
    34723624#if DEBUG_MEMC_WRITE
    34733625                        if(m_debug)
    3474                             std::cout << "  <MEMC " << name() << " WRITE_BC_TRT_LOCK> Check TRT"
    3475                                 << " : wok = " << wok << " / index = " << wok_index << std::endl;
    3476 #endif
    3477                         m_cpt_write_fsm_n_trt_lock++;
    3478                     }
    3479 
     3626                        std::cout << "  <MEMC "  << name()
     3627                                  << " WRITE_BC_TRT_LOCK> Check TRT : wok = " << wok
     3628                                  << " / index = " << wok_index << std::endl;
     3629#endif
    34803630                    m_cpt_write_fsm_trt_lock++;
    34813631
    … …  
    35683718                    m_cache_directory.write(set, way, entry);
    35693719
     3720                    if ((r_write_pktid.read() & 0x7) == TYPE_SC)
     3721                    {
     3722                        m_llsc_table.sc(r_write_address.read(),
     3723                                        r_write_sc_key.read());
     3724                    }
     3725
    35703726#if DEBUG_MEMC_WRITE
    35713727                    if(m_debug)
    … …  
    36113767                    {
    36123768                        r_write_to_ixr_cmd_req     = true;
    3613                         r_write_to_ixr_cmd_put     = true;
    36143769                        r_write_to_ixr_cmd_index   = r_write_trt_index.read();
    36153770                        r_write_fsm = WRITE_IDLE;
    … …  
    37653920                        r_ixr_cmd_word    = 0;
    37663921                        r_ixr_cmd_fsm     = IXR_CMD_READ_SEND;
    3767                         for( size_t i=0 ; i<m_words ; i++ ) r_ixr_cmd_wdata[i] = entry.wdata[i];
    37683922
    37693923#if DEBUG_MEMC_IXR_CMD
    … …  
    37873941                        r_ixr_cmd_word    = 0;
    37883942                        r_ixr_cmd_fsm     = IXR_CMD_WRITE_SEND;
     3943
     3944                        // Read data from TRT if PUT transaction
     3945                        if (not entry.xram_read)
     3946                        {
    37893947                        for( size_t i=0 ; i<m_words ; i++ ) r_ixr_cmd_wdata[i] = entry.wdata[i];
     3948                        }
    37903949
    37913950#if DEBUG_MEMC_IXR_CMD
    … …  
    38093968                        r_ixr_cmd_word    = 0;
    38103969                        r_ixr_cmd_fsm     = IXR_CMD_CAS_SEND;
     3970
     3971                        // Read data from TRT if PUT transaction
     3972                        if (not entry.xram_read)
     3973                        {
    38113974                        for( size_t i=0 ; i<m_words ; i++ ) r_ixr_cmd_wdata[i] = entry.wdata[i];
     3975                        }
    38123976
    38133977#if DEBUG_MEMC_IXR_CMD
    … …  
    39094073                    if(p_vci_ixr.cmdack)
    39104074                    {
    3911                         if(r_write_to_ixr_cmd_put.read())   // PUT
     4075                        if (not r_ixr_cmd_get.read())   // PUT
    39124076                        {
    39134077                            if(r_ixr_cmd_word.read() == (m_words - 2))
    … …  
    39464110                    if(p_vci_ixr.cmdack)
    39474111                    {
    3948                         if(r_cas_to_ixr_cmd_put.read()) // PUT
     4112                        if (not r_ixr_cmd_get.read()) // PUT
    39494113                        {
    39504114                            if(r_ixr_cmd_word.read() == (m_words - 2))
    … …  
    42914455                    r_xram_rsp_victim_way       = way;
    42924456                    r_xram_rsp_victim_set       = set;
    4293                     r_xram_rsp_victim_nline     = victim.tag*m_sets + set;
     4457                    r_xram_rsp_victim_nline     = (addr_t)victim.tag*m_sets + set;
    42944458                    r_xram_rsp_victim_is_cnt    = victim.is_cnt;
    42954459                    r_xram_rsp_victim_inval     = inval ;
    … …  
    48084972        ////////////////////////////////////////////////////////////////////////////////////
    48094973
    4810         //std::cout << std::endl << "cleanup_fsm" << std::endl;
    4811 
    48124974        switch(r_cleanup_fsm.read())
    48134975        {
    … …  
    48425004                            "MEMC ERROR in CLEANUP_IDLE state : illegal SRCID value");
    48435005
    4844                     m_cpt_cleanup++;
     5006                    // <Activity Counters>
     5007                    if (is_local_req(srcid)) {
     5008                        m_cpt_cleanup_local++;
     5009                    }
     5010                    else {
     5011                        m_cpt_cleanup_remote++;
     5012                        m_cpt_cleanup_cost += req_distance(srcid);
     5013                    }
     5014                    // </Activity Counters>
    48455015                    cc_receive_to_cleanup_fifo_get = true;
    48465016                    r_cleanup_fsm                  = CLEANUP_GET_NLINE;
    … …  
    55895759                        if(m_cmd_cas_eop_fifo.read())
    55905760                        {
    5591                             m_cpt_cas++;
    55925761                            r_cas_fsm = CAS_DIR_REQ;
    55935762                        }
    … …  
    61356304                    {
    61366305                        r_cas_to_ixr_cmd_req     = true;
    6137                         r_cas_to_ixr_cmd_put     = true;
    61386306                        r_cas_to_ixr_cmd_index   = r_cas_trt_index.read();
    61396307                        r_cas_fsm                = CAS_IDLE;
    … …  
    62726440                    {
    62736441                        r_cas_to_ixr_cmd_req        = true;
    6274                         r_cas_to_ixr_cmd_put        = false;
    62756442                        r_cas_to_ixr_cmd_index      = r_cas_trt_index.read();
    62766443                        r_cas_fsm                   = CAS_WAIT;
    … …  
    63286495                    {
    63296496                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6330                         m_cpt_inval++;
    63316497                        break;
    63326498                    }
    … …  
    63346500                    {
    63356501                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6336                         m_cpt_inval++;
    63376502                        break;
    63386503                    }
    … …  
    63426507                    {
    63436508                        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6344                         m_cpt_update++;
    63456509                        break;
    63466510                    }
    … …  
    63486512                    {
    63496513                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6350                         m_cpt_inval++;
    63516514                        break;
    63526515                    }
    … …  
    63566519                    {
    63576520                        r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6358                         m_cpt_update++;
    63596521                        break;
    63606522                    }
    … …  
    63626524                    {
    63636525                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6364                         m_cpt_inval++;
    63656526                        break;
    63666527                    }
    … …  
    63696530                    {
    63706531                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6371                         m_cpt_inval++;
    63726532                        break;
    63736533                    }
    … …  
    63756535                    {
    63766536                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6377                         m_cpt_inval++;
    63786537                        break;
    63796538                    }
    … …  
    63876546                    {
    63886547                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6389                         m_cpt_inval++;
    63906548                        break;
    63916549                    }
    … …  
    63936551                    {
    63946552                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6395                         m_cpt_inval++;
    63966553                        break;
    63976554                    }
    … …  
    64016558                    {
    64026559                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6403                         m_cpt_inval++;
    64046560                        break;
    64056561                    }
    … …  
    64076563                    {
    64086564                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6409                         m_cpt_inval++;
    64106565                        break;
    64116566                    }
    … …  
    64156570                    {
    64166571                        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6417                         m_cpt_update++;
    64186572                        break;
    64196573                    }
    … …  
    64216575                    {
    64226576                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6423                         m_cpt_inval++;
    64246577                        break;
    64256578                    }
    … …  
    64296582                    {
    64306583                        r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6431                         m_cpt_update++;
    64326584                        break;
    64336585                    }
    … …  
    64356587                    {
    64366588                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6437                         m_cpt_inval++;
    64386589                        break;
    64396590                    }
    … …  
    64486599                    {
    64496600                        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6450                         m_cpt_update++;
    64516601                        break;
    64526602                    }
    … …  
    64546604                    {
    64556605                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6456                         m_cpt_inval++;
    64576606                        break;
    64586607                    }
    … …  
    64626611                    {
    64636612                        r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6464                         m_cpt_update++;
    64656613                        break;
    64666614                    }
    … …  
    64696617                    {
    64706618                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6471                         m_cpt_inval++;
    64726619                        break;
    64736620                    }
    … …  
    64766623                    {
    64776624                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6478                         m_cpt_inval++;
    64796625                        break;
    64806626                    }
    … …  
    64826628                    {
    64836629                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6484                         m_cpt_inval++;
    64856630                        break;
    64866631                    }
    … …  
    64906635                    {
    64916636                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6492                         m_cpt_inval++;
    64936637                        break;
    64946638                    }
    … …  
    64966640                    {
    64976641                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6498                         m_cpt_inval++;
    64996642                        break;
    65006643                    }
    … …  
    65086651                    {
    65096652                        r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6510                         m_cpt_update++;
    65116653                        break;
    65126654                    }
    … …  
    65146656                    {
    65156657                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6516                         m_cpt_inval++;
    65176658                        break;
    65186659                    }
    … …  
    65216662                    {
    65226663                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6523                         m_cpt_inval++;
    65246664                        break;
    65256665                    }
    … …  
    65276667                    {
    65286668                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6529                         m_cpt_inval++;
    65306669                        break;
    65316670                    }
    … …  
    65346673                    {
    65356674                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6536                         m_cpt_inval++;
    65376675                        break;
    65386676                    }
    … …  
    65406678                    {
    65416679                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6542                         m_cpt_inval++;
    65436680                        break;
    65446681                    }
    … …  
    65476684                    {
    65486685                        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6549                         m_cpt_update++;
    65506686                        break;
    65516687                    }
    … …  
    65536689                    {
    65546690                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6555                         m_cpt_inval++;
    65566691                        break;
    65576692                    }
    … …  
    65646699                    {
    65656700                        if(not p_dspin_m2p.read) break;
     6701                        // <Activity Counters>
     6702                        if (is_local_req(m_config_to_cc_send_srcid_fifo.read()))
     6703                        {
     6704                            m_cpt_m_inval_local++;
     6705                        }
     6706                        else
     6707                        {
     6708                            m_cpt_m_inval_remote++;
     6709                            m_cpt_m_inval_cost += req_distance(m_config_to_cc_send_srcid_fifo.read());
     6710                        }
     6711                        // </Activity Counters>
    65666712                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    65676713                        break;
    65686714                    }
    65696715                    if(r_config_to_cc_send_multi_req.read()) r_config_to_cc_send_multi_req = false;
     6716                    // <Activity Counters>
     6717                    m_cpt_m_inval++;
     6718                    // </Activity Counters>
    65706719                    r_cc_send_fsm = CC_SEND_CONFIG_IDLE;
    65716720                    break;
    … …  
    65756724                {
    65766725                    if(not p_dspin_m2p.read) break;
    6577                     m_cpt_inval_mult++;
    65786726                    config_to_cc_send_fifo_get = true;
    65796727                    r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    … …  
    65986746                {
    65996747                    if(not p_dspin_m2p.read) break;
    6600                     m_cpt_inval_brdcast++;
     6748                    // <Activity Counters>
     6749                    m_cpt_br_inval++;
     6750                    // </Activity Counters>
    66016751                    r_config_to_cc_send_brdcast_req = false;
    66026752                    r_cc_send_fsm = CC_SEND_CONFIG_IDLE;
    … …  
    66166766                    {
    66176767                        if(not p_dspin_m2p.read) break;
     6768                        // <Activity Counters>
     6769                        if (is_local_req(m_xram_rsp_to_cc_send_srcid_fifo.read()))
     6770                        {
     6771                            m_cpt_m_inval_local++;
     6772                        }
     6773                        else
     6774                        {
     6775                            m_cpt_m_inval_remote++;
     6776                            m_cpt_m_inval_cost += req_distance(m_xram_rsp_to_cc_send_srcid_fifo.read());
     6777                        }
     6778                        // </Activity Counters>
    66186779                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    66196780                        break;
    66206781                    }
    66216782                    if(r_xram_rsp_to_cc_send_multi_req.read()) r_xram_rsp_to_cc_send_multi_req = false;
     6783                    // <Activity Counters>
     6784                    m_cpt_m_inval++;
     6785                    // </Activity Counters>
    66226786                    r_cc_send_fsm = CC_SEND_XRAM_RSP_IDLE;
    66236787                    break;
    … …  
    66276791                {
    66286792                    if(not p_dspin_m2p.read) break;
    6629                     m_cpt_inval_mult++;
    66306793                    xram_rsp_to_cc_send_fifo_get = true;
    66316794                    r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    … …  
    66506813                {
    66516814                    if(not p_dspin_m2p.read) break;
    6652                     m_cpt_inval_brdcast++;
     6815                    // <Activity Counters>
     6816                    m_cpt_br_inval++;
     6817                    // </Activity Counters>
    66536818                    r_xram_rsp_to_cc_send_brdcast_req = false;
    66546819                    r_cc_send_fsm = CC_SEND_XRAM_RSP_IDLE;
    … …  
    66746839                    if(not p_dspin_m2p.read) break;
    66756840
    6676                     m_cpt_inval_brdcast++;
     6841                    // <Activity Counters>
     6842                    m_cpt_br_inval++;
     6843                    // </Activity Counters>
    66776844
    66786845                    r_write_to_cc_send_brdcast_req = false;
    … …  
    66936860                    {
    66946861                        if(not p_dspin_m2p.read) break;
     6862                        // <Activity Counters>
     6863                        if (is_local_req(m_write_to_cc_send_srcid_fifo.read()))
     6864                        {
     6865                            m_cpt_update_local++;
     6866                        }
     6867                        else
     6868                        {
     6869                            m_cpt_update_remote++;
     6870                            m_cpt_update_cost += req_distance(m_write_to_cc_send_srcid_fifo.read());
     6871                        }
     6872                        // </Activity Counters>
    66956873
    66966874                        r_cc_send_fsm = CC_SEND_WRITE_UPDT_NLINE;
    … …  
    67036881                    }
    67046882
     6883                    // <Activity Counters>
     6884                    m_cpt_update++;
     6885                    // </Activity Counters>
    67056886                    r_cc_send_fsm = CC_SEND_WRITE_IDLE;
    67066887                    break;
    … …  
    67106891                {
    67116892                    if(not p_dspin_m2p.read) break;
    6712                     m_cpt_update_mult++;
    67136893
    67146894                    r_cc_send_cpt = 0;
    … …  
    67276907                {
    67286908                    if(not p_dspin_m2p.read) break;
    6729                     if(r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1))
     6909                    if (r_cc_send_cpt.read() == r_write_to_cc_send_count.read())
    67306910                    {
    67316911                        write_to_cc_send_fifo_get = true;
    … …  
    67486928                {
    67496929                    if(not p_dspin_m2p.read) break;
    6750                     m_cpt_inval_brdcast++;
     6930                    // <Activity Counters>
     6931                    m_cpt_br_inval++;
     6932                    // </Activity Counters>
    67516933
    67526934                    r_cas_to_cc_send_brdcast_req = false;
    … …  
    67676949                    {
    67686950                        if(not p_dspin_m2p.read) break;
    6769 
     6951                        // <Activity Counters>
     6952                        if (is_local_req(m_cas_to_cc_send_srcid_fifo.read()))
     6953                        {
     6954                            m_cpt_update_local++;
     6955                        }
     6956                        else
     6957                        {
     6958                            m_cpt_update_remote++;
     6959                            m_cpt_update_cost += req_distance(m_cas_to_cc_send_srcid_fifo.read());
     6960                        }
     6961                        // </Activity Counters>
    67706962                        r_cc_send_fsm = CC_SEND_CAS_UPDT_NLINE;
    67716963                        break;
    … …  
    67786970                    }
    67796971
     6972                    // <Activity Counters>
     6973                    m_cpt_update++;
     6974                    // </Activity Counters>
    67806975                    r_cc_send_fsm = CC_SEND_CAS_IDLE;
    67816976                    break;
    … …  
    67856980                {
    67866981                    if(not p_dspin_m2p.read) break;
    6787 
    6788                     m_cpt_update_mult++;
    6789 
    67906982                    r_cc_send_cpt = 0;
    67916983                    r_cc_send_fsm = CC_SEND_CAS_UPDT_DATA;
    … …  
    73597551                /////////////////////////
    73607552            case ALLOC_UPT_MULTI_ACK:     // allocated to MULTI_ACK FSM
    7361                 if ((r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK ) and
    7362                         (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
     7553                if (r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK)
    73637554                {
    73647555                    if (r_write_fsm.read() == WRITE_UPT_LOCK)
    … …  
    78148005                        r_alloc_trt_fsm = ALLOC_TRT_IXR_CMD;
    78158006
    7816                     if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     8007                    else if ((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    78178008                            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    78188009                        r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    … …  
    82018392                        r_alloc_heap_fsm = ALLOC_HEAP_CLEANUP;
    82028393
    8203                     if(r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
     8394                    else if (r_xram_rsp_fsm.read() == XRAM_RSP_HEAP_REQ)
    82048395                        r_alloc_heap_fsm = ALLOC_HEAP_XRAM_RSP;
    82058396                    else
    … …  
    83538544        /////////////////////////////
    83548545    {
     8546#if MONITOR_MEMCACHE_FSM == 1
     8547        p_read_fsm.write        (r_read_fsm.read()       );
     8548        p_write_fsm.write       (r_write_fsm.read()      );
     8549        p_xram_rsp_fsm.write    (r_xram_rsp_fsm.read()   );
     8550        p_cas_fsm.write         (r_cas_fsm.read()        );
     8551        p_cleanup_fsm.write     (r_cleanup_fsm.read()    );
     8552        p_config_fsm.write      (r_config_fsm.read()     );
     8553        p_alloc_heap_fsm.write  (r_alloc_heap_fsm.read() );
     8554        p_alloc_dir_fsm.write   (r_alloc_dir_fsm.read()  );
     8555        p_alloc_trt_fsm.write   (r_alloc_trt_fsm.read()  );
     8556        p_alloc_upt_fsm.write   (r_alloc_upt_fsm.read()  );
     8557        p_alloc_ivt_fsm.write   (r_alloc_ivt_fsm.read()  );
     8558        p_tgt_cmd_fsm.write     (r_tgt_cmd_fsm.read()    );
     8559        p_tgt_rsp_fsm.write     (r_tgt_rsp_fsm.read()    );
     8560        p_ixr_cmd_fsm.write     (r_ixr_cmd_fsm.read()    );
     8561        p_ixr_rsp_fsm.write     (r_ixr_rsp_fsm.read()    );
     8562        p_cc_send_fsm.write     (r_cc_send_fsm.read()    );
     8563        p_cc_receive_fsm.write  (r_cc_receive_fsm.read() );
     8564        p_multi_ack_fsm.write   (r_multi_ack_fsm.read()  );
     8565#endif
     8566
    83558567        ////////////////////////////////////////////////////////////
    83568568        // Command signals on the p_vci_ixr port
    … …  
    88989110
    88999111                    p_dspin_m2p.write = true;
    8900                     p_dspin_m2p.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
     9112                    p_dspin_m2p.eop   = (r_cc_send_cpt.read() == r_write_to_cc_send_count.read());
    89019113                    p_dspin_m2p.data  = flit;
    89029114
    … …  
    90399251            DspinDhccpParam::dspin_set(
    90409252                    flit,
    9041                     r_cleanup_nline.read() & 0xFFFF,
     9253                    r_cleanup_nline.read(),
    90429254                    DspinDhccpParam::CLACK_SET);
    90439255
    … …  
    90939305
    90949306// Local Variables:
    9095 // tab-width: 2
    9096 // c-basic-offset: 2
     9307// tab-width: 4
     9308// c-basic-offset: 4
    90979309// c-file-offsets:((innamespace . 0)(inline-open . 0))
    90989310// indent-tabs-mode: nil
Note: See TracChangeset for help on using the changeset viewer.