Changeset 544 for branches/ODCCP


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

ODCCP merge the components with the version 543 in trunk.

Location:
branches/ODCCP
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/ODCCP/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h

    r494 r544  
    156156    static const uint8_t  BE_WIDTH                     = 4;
    157157    static const uint8_t  DATA_WIDTH                   = 32;
    158     static const uint8_t  SET_INDEX_WIDTH              = 16;
     158    static const uint8_t  SET_INDEX_WIDTH              = 6;
    159159    static const uint8_t  WAY_INDEX_WIDTH              = 2;
    160160    static const uint8_t  BROADCAST_BOX_WIDTH          = 20;
  • branches/ODCCP/lib/generic_tlb_odccp/include/generic_tlb.h

    r492 r544  
    556556        }
    557557
    558         assert("all TLB ways can't be new at the same time");
     558        assert(false && "all TLB ways can't be new at the same time");
    559559    } // end select()
    560560
     
    594594        m_nline[way*m_nsets+set]           = nline;
    595595        m_valid[way*m_nsets+set]           = true;
    596         m_recent[way*m_nsets+set]          = true;
     596        //m_recent[way*m_nsets+set]          = true;
    597597        m_local[way*m_nsets+set]           = (((pte_flags & PTE_L_MASK) >> PTE_L_SHIFT) == 1) ? true : false;
    598598        m_remote[way*m_nsets+set]          = (((pte_flags & PTE_R_MASK) >> PTE_R_SHIFT) == 1) ? true : false;
     
    604604        m_dirty[way*m_nsets+set]           = (((pte_flags & PTE_D_MASK) >> PTE_D_SHIFT) == 1) ? true : false;
    605605        m_non_coherent[way*m_nsets+set]    = (((pte_flags & PTE_NCC_MASK) >> PTE_NCC_SHIFT) == 1) ? true : false; // for ODCCP
     606        set_recent(way, set);
    606607    }  // end write()
    607608
  • branches/ODCCP/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r541 r544  
    38263826                                // to avoid dead-lock in case of simultaneous ITLB miss
    38273827    {
     3828        // coherence clack request (from DSPIN CLACK)
     3829        if ( r_dcache_clack_req.read() )
     3830        {
     3831            r_dcache_fsm = DCACHE_CC_CHECK;
     3832            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3833            break;
     3834        }
     3835
     3836        // coherence request (from CC_RECEIVE FSM)
     3837        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
     3838        {
     3839            r_dcache_fsm = DCACHE_CC_CHECK;
     3840            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3841            break;
     3842        }
     3843
    38283844        // itlb miss request
    38293845        if ( r_icache_tlb_miss_req.read() )
     
    45394555        {
    45404556            r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
    4541             r_dcache_tlb_inval_line  = r_dcache_cc_send_nline;
     4557            if( not r_dcache_cleanup_victim_req.read() )
     4558                r_dcache_tlb_inval_line  = r_dcache_cc_send_nline;
     4559            else
     4560                r_dcache_tlb_inval_line  = r_dcache_cleanup_victim_nline.read();
    45424561            r_dcache_tlb_inval_set   = 0;
    45434562            r_dcache_fsm_scan_save   = DCACHE_MISS_WAIT;
  • branches/ODCCP/modules/vci_mem_cache/caba/source/include

  • branches/ODCCP/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

    r494 r544  
    235235
    236236      bool hit       = false;
    237       for ( size_t i=0 ; i<m_ways ; i++ ) {
     237        for ( size_t i=0 ; i<m_ways ; i++ )
     238        {
    238239        bool equal = ( m_dir_tab[set][i].tag == tag );
    239240        bool valid = m_dir_tab[set][i].valid;
    240241        hit = equal && valid;
    241         if ( hit ) {                   
     242            if ( hit )
     243            {                   
    242244          way = i;
    243245          break;
    244246        }
    245247      }
    246       if ( hit ) {
     248        if ( hit )
     249        {
    247250        m_lru_tab[set][way].recent = true;
    248251        return DirectoryEntry(m_dir_tab[set][way]);
    249       } else {
     252        }
     253        else
     254        {
    250255        return DirectoryEntry();
    251256      }
  • branches/ODCCP/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r494 r544  
    8080      {
    8181        TGT_CMD_IDLE,
    82         TGT_CMD_ERROR,
    8382        TGT_CMD_READ,
    8483        TGT_CMD_WRITE,
    8584        TGT_CMD_CAS,
     85        TGT_CMD_ERROR,
    8686        TGT_CMD_CONFIG
    8787      };
     
    9090      enum tgt_rsp_fsm_state_e
    9191      {
    92         TGT_RSP_CONFIG_IDLE,
    93         TGT_RSP_TGT_CMD_IDLE,
    9492        TGT_RSP_READ_IDLE,
    9593        TGT_RSP_WRITE_IDLE,
     
    9896        TGT_RSP_MULTI_ACK_IDLE,
    9997        TGT_RSP_CLEANUP_IDLE,
    100         TGT_RSP_CONFIG,
    101         TGT_RSP_TGT_CMD,
     98        TGT_RSP_CONFIG_IDLE,
     99        TGT_RSP_TGT_CMD_IDLE,
    102100        TGT_RSP_READ,
    103101        TGT_RSP_WRITE,
     
    105103        TGT_RSP_XRAM,
    106104        TGT_RSP_MULTI_ACK,
    107         TGT_RSP_CLEANUP
     105        TGT_RSP_CLEANUP,
     106        TGT_RSP_CONFIG,
     107        TGT_RSP_TGT_CMD
    108108      };
    109109
     
    120120      enum cc_send_fsm_state_e
    121121      {
    122         CC_SEND_CONFIG_IDLE,
    123122        CC_SEND_XRAM_RSP_IDLE,
    124123        CC_SEND_WRITE_IDLE,
    125124        CC_SEND_CAS_IDLE,
    126         CC_SEND_CONFIG_INVAL_HEADER,
    127         CC_SEND_CONFIG_INVAL_NLINE,
    128         CC_SEND_CONFIG_BRDCAST_HEADER,
    129         CC_SEND_CONFIG_BRDCAST_NLINE,
     125        CC_SEND_CONFIG_IDLE,
    130126        CC_SEND_XRAM_RSP_BRDCAST_HEADER,
    131127        CC_SEND_XRAM_RSP_BRDCAST_NLINE,
     
    142138        CC_SEND_CAS_UPDT_NLINE,
    143139        CC_SEND_CAS_UPDT_DATA,
    144         CC_SEND_CAS_UPDT_DATA_HIGH
     140        CC_SEND_CAS_UPDT_DATA_HIGH,
     141        CC_SEND_CONFIG_INVAL_HEADER,
     142        CC_SEND_CONFIG_INVAL_NLINE,
     143        CC_SEND_CONFIG_BRDCAST_HEADER,
     144        CC_SEND_CONFIG_BRDCAST_NLINE
    145145      };
    146146
     
    324324      {
    325325        ALLOC_DIR_RESET,
    326         ALLOC_DIR_CONFIG,
    327326        ALLOC_DIR_READ,
    328327        ALLOC_DIR_WRITE,
    329328        ALLOC_DIR_CAS,
    330329        ALLOC_DIR_CLEANUP,
    331         ALLOC_DIR_XRAM_RSP
     330        ALLOC_DIR_XRAM_RSP,
     331        ALLOC_DIR_CONFIG
    332332      };
    333333
     
    414414      uint32_t     m_cpt_cycles;        // Counter of cycles
    415415
    416       uint32_t     m_cpt_read;          // Number of READ transactions
     416      // Counters accessible in software (not yet but eventually)
     417      uint32_t     m_cpt_read_local;     // Number of local READ transactions
    417418      uint32_t     m_cpt_read_remote;   // number of remote READ transactions
    418       uint32_t     m_cpt_read_flits;    // number of flits for READs
    419419      uint32_t     m_cpt_read_cost;     // Number of (flits * distance) for READs
    420420
    421       uint32_t     m_cpt_read_miss;     // Number of MISS READ
    422 
    423       uint32_t     m_cpt_write;         // Number of WRITE transactions
     421      uint32_t     m_cpt_write_local;    // Number of local WRITE transactions
    424422      uint32_t     m_cpt_write_remote;  // number of remote WRITE transactions
    425       uint32_t     m_cpt_write_flits;   // number of flits for WRITEs
     423      uint32_t     m_cpt_write_flits_local;  // number of flits for local WRITEs
     424      uint32_t     m_cpt_write_flits_remote; // number of flits for remote WRITEs
    426425      uint32_t     m_cpt_write_cost;    // Number of (flits * distance) for WRITEs
    427426
     427      uint32_t     m_cpt_ll_local;       // Number of local LL transactions
     428      uint32_t     m_cpt_ll_remote;      // number of remote LL transactions
     429      uint32_t     m_cpt_ll_cost;        // Number of (flits * distance) for LLs
     430
     431      uint32_t     m_cpt_sc_local;       // Number of local SC transactions
     432      uint32_t     m_cpt_sc_remote;      // number of remote SC transactions
     433      uint32_t     m_cpt_sc_cost;        // Number of (flits * distance) for SCs
     434
     435      uint32_t     m_cpt_cas_local;      // Number of local SC transactions
     436      uint32_t     m_cpt_cas_remote;     // number of remote SC transactions
     437      uint32_t     m_cpt_cas_cost;       // Number of (flits * distance) for SCs
     438
     439      uint32_t     m_cpt_update;         // Number of requests causing an UPDATE
     440      uint32_t     m_cpt_update_local;   // Number of local UPDATE transactions
     441      uint32_t     m_cpt_update_remote;  // Number of remote UPDATE transactions
     442      uint32_t     m_cpt_update_cost;    // Number of (flits * distance) for UPDT
     443
     444      uint32_t     m_cpt_m_inval;        // Number of requests causing M_INV
     445      uint32_t     m_cpt_m_inval_local;  // Number of local M_INV transactions
     446      uint32_t     m_cpt_m_inval_remote; // Number of remote M_INV transactions
     447      uint32_t     m_cpt_m_inval_cost;   // Number of (flits * distance) for M_INV
     448
     449      uint32_t     m_cpt_br_inval;       // Number of BROADCAST INVAL
     450
     451      uint32_t     m_cpt_cleanup_local;  // Number of local CLEANUP transactions
     452      uint32_t     m_cpt_cleanup_remote; // Number of remote CLEANUP transactions
     453      uint32_t     m_cpt_cleanup_cost;   // Number of (flits * distance) for CLEANUPs
     454
     455      // Counters not accessible by software
     456      uint32_t     m_cpt_read_miss;      // Number of MISS READ
    428457      uint32_t     m_cpt_write_miss;    // Number of MISS WRITE
    429       uint32_t     m_cpt_write_cells;   // Cumulated length for WRITE transactions
    430458      uint32_t     m_cpt_write_dirty;   // Cumulated length for WRITE transactions
    431       uint32_t     m_cpt_update;        // Number of UPDATE transactions
     459      uint32_t     m_cpt_write_broadcast;// Number of BROADCAST INVAL because write
     460
    432461      uint32_t     m_cpt_trt_rb;        // Read blocked by a hit in trt
    433462      uint32_t     m_cpt_trt_full;      // Transaction blocked due to a full trt
     
    441470      uint32_t     m_cpt_sc;            // Number of SC transactions
    442471      uint32_t     m_cpt_cas;           // Number of CAS transactions
    443      
    444472      uint32_t     m_cpt_read_fsm_dir_lock;        // wait DIR LOCK
    445473      uint32_t     m_cpt_read_fsm_n_dir_lock;      // NB DIR LOCK
     
    520548      uint32_t     m_cpt_heap_unused;            // NB cycles HEAP LOCK unused
    521549
    522       uint32_t     m_cpt_cleanup_cost;  // Number of (flits * distance) for CLEANUPs
    523 
    524550      uint32_t     m_cpt_update_flits;  // Number of flits for UPDATEs
    525       uint32_t     m_cpt_update_cost;   // Number of (flits * distance) for UPDATEs
    526 
    527551      uint32_t     m_cpt_inval_cost;    // Number of (flits * distance) for INVALs
    528552
    529553      uint32_t     m_cpt_get;
    530 
    531554      uint32_t     m_cpt_put;
    532555
     
    546569      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
    547570
     571#if MONITOR_MEMCACHE_FSM == 1
     572      sc_out<int> p_read_fsm;
     573      sc_out<int> p_write_fsm;
     574      sc_out<int> p_xram_rsp_fsm;
     575      sc_out<int> p_cas_fsm;
     576      sc_out<int> p_cleanup_fsm;
     577      sc_out<int> p_config_fsm;
     578      sc_out<int> p_alloc_heap_fsm;
     579      sc_out<int> p_alloc_dir_fsm;
     580      sc_out<int> p_alloc_trt_fsm;
     581      sc_out<int> p_alloc_upt_fsm;
     582      sc_out<int> p_alloc_ivt_fsm;
     583      sc_out<int> p_tgt_cmd_fsm;
     584      sc_out<int> p_tgt_rsp_fsm;
     585      sc_out<int> p_ixr_cmd_fsm;
     586      sc_out<int> p_ixr_rsp_fsm;
     587      sc_out<int> p_cc_send_fsm;
     588      sc_out<int> p_cc_receive_fsm;
     589      sc_out<int> p_multi_ack_fsm;
     590#endif
     591
    548592      VciMemCache(
    549593          sc_module_name name,                                // Instance Name
     
    553597          const soclib::common::IntTab       &tgtid_d,        // global index INT network
    554598          const size_t                       cc_global_id,    // global index CC network
     599          const size_t                       x_width,         // X width in platform
     600          const size_t                       y_width,         // Y width in platform
    555601          const size_t                       nways,           // Number of ways per set
    556602          const size_t                       nsets,           // Number of sets
     
    566612      ~VciMemCache();
    567613
    568       void clear_stats();
    569       void print_stats();
     614      void print_stats(bool activity_counters, bool stats);
    570615      void print_trace();
    571616      void cache_monitor(addr_t addr);
     
    578623      void genMoore();
    579624      void check_monitor(addr_t addr, data_t data, bool read);
     625      uint32_t req_distance(uint32_t req_srcid);
     626      bool is_local_req(uint32_t req_srcid);
    580627
    581628      // Component attributes
     
    591638      const size_t                       m_words;            // Number of words in a line
    592639      const size_t                       m_cc_global_id;     // global_index on cc network
     640      const size_t                       m_xwidth;           // number of x bits in platform
     641      const size_t                       m_ywidth;           // number of y bits in platform
    593642      size_t                             m_debug_start_cycle;
    594643      bool                               m_debug_ok;
     
    665714
    666715      sc_signal<int>         r_tgt_cmd_fsm;
    667       sc_signal<size_t>      r_tgt_cmd_srcid;           // srcid for response to config
    668       sc_signal<size_t>      r_tgt_cmd_trdid;           // trdid for response to config
    669       sc_signal<size_t>      r_tgt_cmd_pktid;           // pktid for response to config
    670716
    671717      ///////////////////////////////////////////////////////
     
    696742      sc_signal<bool>     r_config_to_ixr_cmd_req;    // valid request
    697743      sc_signal<size_t>   r_config_to_ixr_cmd_index;  // TRT index
    698 
    699744
    700745      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
     
    776821      sc_signal<size_t>   r_write_upt_index;          // index in Update Table
    777822      sc_signal<bool>     r_write_sc_fail;            // sc command failed
    778       sc_signal<bool>     r_write_pending_sc;         // sc command pending
     823      sc_signal<data_t>   r_write_sc_key;             // sc command key
     824      sc_signal<bool>     r_write_bc_data_we;         // Write enable for data buffer
    779825
    780826      // Buffer between WRITE fsm and TGT_RSP fsm (acknowledge a write command from L1)
     
    787833      // Buffer between WRITE fsm and IXR_CMD fsm
    788834      sc_signal<bool>     r_write_to_ixr_cmd_req;     // valid request
    789       sc_signal<bool>     r_write_to_ixr_cmd_put;     // request type (GET/PUT)
    790835      sc_signal<size_t>   r_write_to_ixr_cmd_index;   // TRT index
    791836
     
    891936      // Buffer between CAS fsm and IXR_CMD fsm
    892937      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
    893       sc_signal<bool>     r_cas_to_ixr_cmd_put;   // request type (GET/PUT)
    894938      sc_signal<size_t>   r_cas_to_ixr_cmd_index; // TRT index
    895939
  • 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.