Changeset 785


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

MESI branch:

  • Cosmetic
  • Changing counters definitions and tags
  • Renaming dspin_dhccp_param to dspin_hmesi_param
Location:
branches/MESI
Files:
6 edited
2 moved

Legend:

Unmodified
Added
Removed
  • branches/MESI/communication/dspin_dhccp_param/caba/metadata/dspin_hmesi_param.sd

    r784 r785  
    1 Module('caba:dspin_dhccp_param',
    2            classname = 'soclib::caba::DspinDhccpParam',
    3            header_files = ['../source/include/dspin_dhccp_param.h',]
     1Module('caba:dspin_hmesi_param',
     2           classname = 'soclib::caba::DspinHmesiParam',
     3           header_files = ['../source/include/dspin_hmesi_param.h',]
    44)
     5
  • branches/MESI/communication/dspin_dhccp_param/caba/source/include/dspin_hmesi_param.h

    r784 r785  
    11/* -*- c++ -*-
    2  * File         : dspin_dhccp_param.h
     2 * File         : dspin_hmesi_param.h
    33 * Date         : 01/03/2013
    44 * Copyright    : UPMC / LIP6
     
    2727
    2828
    29 #ifndef DSPIN_DHCCP_PARAMS_H
    30 #define DSPIN_DHCCP_PARAMS_H
     29#ifndef DSPIN_HMESI_PARAMS_H
     30#define DSPIN_HMESI_PARAMS_H
    3131
    3232#include <inttypes.h>
     
    141141    case z: x |= ((y & z##_MASK) << z##_SHIFT);break
    142142
    143 class DspinDhccpParam
     143class DspinHmesiParam
    144144{
    145145  public:
  • branches/MESI/modules/vci_cc_vcache_wrapper/caba/metadata/vci_cc_vcache_wrapper.sd

    r670 r785  
    3232                parameter.Reference('addr_size'))
    3333            ),
    34                         Uses('caba:dspin_dhccp_param'),
     34                        Uses('caba:dspin_hmesi_param'),
    3535        ],
    3636
  • branches/MESI/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r719 r785  
    3535#include <inttypes.h>
    3636#include <systemc>
     37
    3738#include "caba_base_module.h"
    3839#include "multi_write_buffer.h"
     
    4243#include "vci_initiator.h"
    4344#include "dspin_interface.h"
    44 #include "dspin_dhccp_param.h"
     45#include "dspin_hmesi_param.h"
    4546#include "mapping_table.h"
    4647#include "static_assert.h"
  • branches/MESI/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r719 r785  
    2929
    3030#include <cassert>
     31
    3132#include "arithmetics.h"
    3233#include "../include/vci_cc_vcache_wrapper.h"
     
    182183    };
    183184
     185#if 0 // causes compilation warnings if not used
    184186const char *cache_state_str[] = {
    185187        "CACHE_SLOT_STATE_INVALID",
     
    189191        "CACHE_SLOT_STATE_ZOMBI",
    190192    };
     193#endif
     194
    191195}
    192196
     
    38333837                                r_cas_local_word.read(),
    38343838                                r_dcache_vci_cas_new.read());
    3835 
    3836                //r_dcache.write_dir( r_cas_local_way.read(),
    3837                //                    r_cas_local_set.read(),
    3838                //                    CACHE_SLOT_STATE_MODIFIED );
    38393839            }
    38403840
     
    43234323
    43244324        uint32_t rdata;
    4325         size_t   way;
    4326         size_t   set;
     4325        size_t   way = 0; // To avoid g++ warning
     4326        size_t   set = 0; // To avoid g++ warning
    43274327        size_t   word;
    43284328        r_dcache.read_neutral(r_dcache_xtn_data_addr.read(),
     
    58815881            if ( p_vci.rspval.read() )
    58825882            {
    5883                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5883                if ((p_vci.rerror.read() & 0x1) != 0)  // error reported
    58845884                {
    58855885                    r_vci_rsp_ins_error = true;
     
    59475947            if ( p_vci.rspval.read() )
    59485948            {
    5949                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5949                if ( (p_vci.rerror.read() & 0x1) != 0 )  // error reported
    59505950                {
    59515951                    r_vci_rsp_data_error = true;
     
    59545954                else                                        // no error reported
    59555955                {
    5956 
    5957 
    59585956                    if ( r_vci_rsp_fifo_dcache.wok() )
    59595957                    {
     
    59615959                        "The VCI response packet for data miss is too long");
    59625960
    5963                         r_vci_rsp_cpt                 = r_vci_rsp_cpt.read() + 1;
    5964                         vci_rsp_fifo_dcache_put       = true,
    5965                         vci_rsp_fifo_dcache_data      = p_vci.rdata.read();
    5966 
    5967                         if ( p_vci.reop.read() )
     5961                        r_vci_rsp_cpt            = r_vci_rsp_cpt.read() + 1;
     5962                        vci_rsp_fifo_dcache_put  = true,
     5963                        vci_rsp_fifo_dcache_data = p_vci.rdata.read();
     5964
     5965                        if (p_vci.reop.read())
    59685966                        {
    59695967                            r_dcache_rsp_state = ((p_vci.rpktid.read() & 0x8) == 0x8);  // EXCLUSIVE = 0x8
    5970                             if (r_vci_rsp_cpt.read() != m_dcache_words - 1) std::cout << "assert on proc " << name() << std::endl;
    5971                             assert( (r_vci_rsp_cpt.read() == m_dcache_words - 1) and
    5972                             "The VCI response packet for data miss is too short");
    5973 
    5974                             r_vci_rsp_fsm     = RSP_IDLE;
     5968                            assert( (r_vci_rsp_cpt.read() == m_dcache_words - 1) and "The VCI response packet for data miss is too short");
     5969
     5970                            r_vci_rsp_fsm = RSP_IDLE;
    59755971                        }
    59765972                    }
     
    59875983                "illegal VCI response packet for uncachable read data");
    59885984
    5989                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     5985                if ( (p_vci.rerror.read() & 0x1) != 0 )  // error reported
    59905986                {
    59915987                    r_vci_rsp_data_error = true;
     
    60106006            if ( p_vci.rspval.read() )
    60116007            {
    6012                 if ( (p_vci.rerror.read()&0x1) != 0 )  // error reported
     6008                if ( (p_vci.rerror.read() & 0x1) != 0 )  // error reported
    60136009                {
    60146010                    r_vci_rsp_data_error = true;
     
    62116207                uint64_t receive_data = p_dspin_m2p.data.read();
    62126208                // initialize coherence packet type
    6213                 uint64_t receive_type = DspinDhccpParam::dspin_get(receive_data,
    6214                                             DspinDhccpParam::M2P_TYPE);
     6209                uint64_t receive_type = DspinHmesiParam::dspin_get(receive_data,
     6210                                            DspinHmesiParam::M2P_TYPE);
    62156211                // test for a broadcast
    6216                 if (DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::M2P_BC))
     6212                if (DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::M2P_BC))
    62176213                {
    62186214                    r_cc_receive_fsm = CC_RECEIVE_BRDCAST_HEADER;
    62196215                }
    62206216                // test for a multi updt
    6221                 else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA)
     6217                else if (receive_type == DspinHmesiParam::TYPE_MULTI_UPDT_DATA)
    62226218                {
    62236219                    r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_HEADER;
    62246220                }
    6225                 else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_INST)
     6221                else if (receive_type == DspinHmesiParam::TYPE_MULTI_UPDT_INST)
    62266222                {
    62276223                    r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_HEADER;
    62286224                }
    62296225                // test for a multi inval
    6230                 else if (receive_type == DspinDhccpParam::TYPE_MULTI_INVAL_DATA)
     6226                else if (receive_type == DspinHmesiParam::TYPE_MULTI_INVAL_DATA)
    62316227                {
    62326228                    r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_HEADER;
     
    62476243                not (r_cc_receive_dcache_req.read()))
    62486244            {
    6249                 r_cc_receive_dcache_srcid = DspinDhccpParam::dspin_get(receive_data,
    6250                                             DspinDhccpParam::BROADCAST_SRCID);
    6251 
    6252                 r_cc_receive_dcache_inval_is_config = DspinDhccpParam::dspin_get(receive_data,
    6253                                                       DspinDhccpParam::BRDCAST_IS_CONFIG);
    6254 
    6255                 r_cc_receive_dcache_is_shared = DspinDhccpParam::dspin_get(receive_data,
    6256                                             DspinDhccpParam::BRDCAST_IS_SHARED);
    6257 
    6258                 r_cc_receive_fsm          = CC_RECEIVE_BRDCAST_NLINE;
     6245                r_cc_receive_dcache_srcid = DspinHmesiParam::dspin_get(receive_data,
     6246                                            DspinHmesiParam::BROADCAST_SRCID);
     6247
     6248                r_cc_receive_dcache_inval_is_config = DspinHmesiParam::dspin_get(receive_data,
     6249                                                      DspinHmesiParam::BRDCAST_IS_CONFIG);
     6250
     6251                r_cc_receive_dcache_is_shared = DspinHmesiParam::dspin_get(receive_data,
     6252                                            DspinHmesiParam::BRDCAST_IS_SHARED);
     6253
     6254                r_cc_receive_fsm = CC_RECEIVE_BRDCAST_NLINE;
    62596255            }
    62606256            break;
     
    62786274                // request dcache to handle the BROADCAST
    62796275                r_cc_receive_dcache_req = true;
    6280                 r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,
    6281                                              DspinDhccpParam::BROADCAST_NLINE);
     6276                r_cc_receive_dcache_nline  = DspinHmesiParam::dspin_get(receive_data,
     6277                                             DspinHmesiParam::BROADCAST_NLINE);
    62826278                r_cc_receive_dcache_type = CC_TYPE_BRDCAST;
    62836279                // request icache to handle the BROADCAST
    62846280                r_cc_receive_icache_req = true;
    6285                 r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,
    6286                                              DspinDhccpParam::BROADCAST_NLINE);
     6281                r_cc_receive_icache_nline  = DspinHmesiParam::dspin_get(receive_data,
     6282                                             DspinHmesiParam::BROADCAST_NLINE);
    62876283                r_cc_receive_icache_type = CC_TYPE_INVAL;
    62886284                // get back to idle state
     
    63036299                // sample updt tab index in the HEADER, then skip to second flit
    63046300                r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_NLINE;
    6305                 r_cc_receive_dcache_inval_is_config = DspinDhccpParam::dspin_get(receive_data,
    6306                                                       DspinDhccpParam::MULTI_INVAL_IS_CONFIG);
    6307 
    6308                 r_cc_receive_dcache_is_shared = DspinDhccpParam::dspin_get(receive_data,
    6309                                             DspinDhccpParam::MULTI_INVAL_IS_SHARED);
     6301                r_cc_receive_dcache_inval_is_config = DspinHmesiParam::dspin_get(receive_data,
     6302                                                      DspinHmesiParam::MULTI_INVAL_IS_CONFIG);
     6303
     6304                r_cc_receive_dcache_is_shared = DspinHmesiParam::dspin_get(receive_data,
     6305                                            DspinHmesiParam::MULTI_INVAL_IS_SHARED);
    63106306            }
    63116307            break;
     
    63296325                // request dcache to handle the INVAL
    63306326                r_cc_receive_dcache_req = true;
    6331                 r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
     6327                r_cc_receive_dcache_nline = DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::MULTI_INVAL_NLINE);
    63326328                r_cc_receive_dcache_type = CC_TYPE_INVAL;
    63336329                // get back to idle state
     
    63486344                // request icache to handle the INVAL
    63496345                r_cc_receive_icache_req = true;
    6350                 r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
     6346                r_cc_receive_icache_nline = DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::MULTI_INVAL_NLINE);
    63516347                r_cc_receive_icache_type = CC_TYPE_INVAL;
    63526348                // get back to idle state
     
    63656361            if (not r_cc_receive_dcache_req.read())
    63666362            {
    6367                 r_cc_receive_dcache_updt_tab_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::CC_UPDT_IVT_INDEX);
     6363                r_cc_receive_dcache_updt_tab_idx  = DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::CC_UPDT_IVT_INDEX);
    63686364                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_NLINE;
    63696365                break;
     
    63806376            if (not r_cc_receive_icache_req.read())
    63816377            {
    6382                 r_cc_receive_icache_updt_tab_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::CC_UPDT_IVT_INDEX);
     6378                r_cc_receive_icache_updt_tab_idx  = DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::CC_UPDT_IVT_INDEX);
    63836379                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_NLINE;
    63846380                break;
     
    63976393            {
    63986394                r_cc_receive_dcache_req = true;
    6399                 r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
     6395                r_cc_receive_dcache_nline  = DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::MULTI_UPDT_NLINE);
    64006396                r_cc_receive_dcache_type = CC_TYPE_UPDT;
    64016397                // get back to idle state
     
    64156411            {
    64166412                r_cc_receive_icache_req = true;
    6417                 r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
     6413                r_cc_receive_icache_nline  = DspinHmesiParam::dspin_get(receive_data,DspinHmesiParam::MULTI_UPDT_NLINE);
    64186414                r_cc_receive_icache_type = CC_TYPE_UPDT;
    64196415                // get back to idle state
     
    64286424    ///////////////// DSPIN CLACK interface ///////////////
    64296425   
    6430     uint64_t clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
    6431                                                      DspinDhccpParam::CLACK_TYPE);
    6432 
    6433     size_t clack_way  = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
    6434                                                    DspinDhccpParam::CLACK_WAY);
    6435 
    6436     size_t clack_set  = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
    6437                                                    DspinDhccpParam::CLACK_SET);
     6426    uint64_t clack_type = DspinHmesiParam::dspin_get(r_dspin_clack_flit.read(),
     6427                                                     DspinHmesiParam::CLACK_TYPE);
     6428
     6429    size_t clack_way  = DspinHmesiParam::dspin_get(r_dspin_clack_flit.read(),
     6430                                                   DspinHmesiParam::CLACK_WAY);
     6431
     6432    size_t clack_set  = DspinHmesiParam::dspin_get(r_dspin_clack_flit.read(),
     6433                                                   DspinHmesiParam::CLACK_SET);
    64386434
    64396435    bool dspin_clack_get      = false;
    6440     bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA);
    6441     bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST);
     6436    bool dcache_clack_request = (clack_type == DspinHmesiParam::TYPE_CLACK_DATA);
     6437    bool icache_clack_request = (clack_type == DspinHmesiParam::TYPE_CLACK_INST);
    64426438
    64436439    if (r_dspin_clack_req.read())
     
    66766672        {
    66776673            // initialize dspin send data
    6678 //             DspinDhccpParam::dspin_set(dspin_send_data,
    6679 //                                       0,
    6680 //                                       DspinDhccpParam::P2M_EOP);
    6681             DspinDhccpParam::dspin_set(dspin_send_data,
     6674            DspinHmesiParam::dspin_set(dspin_send_data,
    66826675                                       m_cc_global_id,
    6683                                        DspinDhccpParam::CLEANUP_SRCID);
    6684             DspinDhccpParam::dspin_set(dspin_send_data,
     6676                                       DspinHmesiParam::CLEANUP_SRCID);
     6677            DspinHmesiParam::dspin_set(dspin_send_data,
    66856678                                       0,
    6686                                        DspinDhccpParam::P2M_BC);
     6679                                       DspinHmesiParam::P2M_BC);
    66876680
    66886681            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    66906683                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
    66916684                                >> (m_nline_width - m_x_width - m_y_width)
    6692                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6693                 DspinDhccpParam::dspin_set(dspin_send_data,
     6685                                << (DspinHmesiParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6686                DspinHmesiParam::dspin_set(dspin_send_data,
    66946687                                           dest,
    6695                                            DspinDhccpParam::CLEANUP_DEST);
    6696 
    6697                 DspinDhccpParam::dspin_set(dspin_send_data,
     6688                                           DspinHmesiParam::CLEANUP_DEST);
     6689
     6690                DspinHmesiParam::dspin_set(dspin_send_data,
    66986691                                           (r_dcache_cc_send_nline.read() & 0x300000000ULL)>>32,
    6699                                            DspinDhccpParam::CLEANUP_NLINE_MSB);
    6700 
    6701                 DspinDhccpParam::dspin_set(dspin_send_data,
     6692                                           DspinHmesiParam::CLEANUP_NLINE_MSB);
     6693
     6694                DspinHmesiParam::dspin_set(dspin_send_data,
    67026695                                           r_dcache_cc_send_way.read(),
    6703                                            DspinDhccpParam::CLEANUP_WAY_INDEX);
    6704 
    6705                 DspinDhccpParam::dspin_set(dspin_send_data,
    6706                                            DspinDhccpParam::TYPE_CLEANUP_DATA,
    6707                                            DspinDhccpParam::P2M_TYPE);
    6708 
    6709                 DspinDhccpParam::dspin_set(dspin_send_data,
     6696                                           DspinHmesiParam::CLEANUP_WAY_INDEX);
     6697
     6698                DspinHmesiParam::dspin_set(dspin_send_data,
     6699                                           DspinHmesiParam::TYPE_CLEANUP_DATA,
     6700                                           DspinHmesiParam::P2M_TYPE);
     6701
     6702                DspinHmesiParam::dspin_set(dspin_send_data,
    67106703                                           (r_dcache_cc_line_no_shared.read() and (r_cc_send_last_client.read() == 0) and not r_dcache_cc_send_inval_is_config.read()),
    6711                                            DspinDhccpParam::DATA_NO_SHARED);
     6704                                           DspinHmesiParam::DATA_NO_SHARED);
    67126705            }
    67136706            else                                // icache active request
     
    67156708                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
    67166709                                >> (m_nline_width - m_x_width - m_y_width)
    6717                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6718 
    6719                 DspinDhccpParam::dspin_set(dspin_send_data,
     6710                                << (DspinHmesiParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6711
     6712                DspinHmesiParam::dspin_set(dspin_send_data,
    67206713                                           dest,
    6721                                            DspinDhccpParam::CLEANUP_DEST);
    6722 
    6723                 DspinDhccpParam::dspin_set(dspin_send_data,
     6714                                           DspinHmesiParam::CLEANUP_DEST);
     6715
     6716                DspinHmesiParam::dspin_set(dspin_send_data,
    67246717                                           (r_icache_cc_send_nline.read() & 0x300000000ULL)>>32,
    6725                                            DspinDhccpParam::CLEANUP_NLINE_MSB);
    6726 
    6727                 DspinDhccpParam::dspin_set(dspin_send_data,
     6718                                           DspinHmesiParam::CLEANUP_NLINE_MSB);
     6719
     6720                DspinHmesiParam::dspin_set(dspin_send_data,
    67286721                                           r_icache_cc_send_way.read(),
    6729                                            DspinDhccpParam::CLEANUP_WAY_INDEX);
    6730 
    6731                 DspinDhccpParam::dspin_set(dspin_send_data,
    6732                                            DspinDhccpParam::TYPE_CLEANUP_INST,
    6733                                            DspinDhccpParam::P2M_TYPE);
    6734 
    6735                 DspinDhccpParam::dspin_set(dspin_send_data,
     6722                                           DspinHmesiParam::CLEANUP_WAY_INDEX);
     6723
     6724                DspinHmesiParam::dspin_set(dspin_send_data,
     6725                                           DspinHmesiParam::TYPE_CLEANUP_INST,
     6726                                           DspinHmesiParam::P2M_TYPE);
     6727
     6728                DspinHmesiParam::dspin_set(dspin_send_data,
    67366729                                           0,
    6737                                            DspinDhccpParam::DATA_NO_SHARED);
     6730                                           DspinHmesiParam::DATA_NO_SHARED);
    67386731
    67396732
     
    67516744            if(r_cc_send_last_client.read() == 0) // dcache active request
    67526745            {
    6753                 DspinDhccpParam::dspin_set(dspin_send_data,
     6746                DspinHmesiParam::dspin_set(dspin_send_data,
    67546747                                           r_dcache_cc_send_nline.read() & 0xFFFFFFFFULL,
    6755                                            DspinDhccpParam::CLEANUP_NLINE_LSB);
     6748                                           DspinHmesiParam::CLEANUP_NLINE_LSB);
    67566749            }
    67576750            else                                  // icache active request
    67586751            {
    6759                 DspinDhccpParam::dspin_set(dspin_send_data,
     6752                DspinHmesiParam::dspin_set(dspin_send_data,
    67606753                                           r_icache_cc_send_nline.read() & 0xFFFFFFFFULL,
    6761                                            DspinDhccpParam::CLEANUP_NLINE_LSB);
     6754                                           DspinHmesiParam::CLEANUP_NLINE_LSB);
    67626755            }
    67636756            // send flit
     
    67706763        case CC_SEND_DATA_UPDT:
    67716764        {
    6772             DspinDhccpParam::dspin_set(dspin_send_data,
     6765            DspinHmesiParam::dspin_set(dspin_send_data,
    67736766                                       r_cc_send_data_fifo.read(),
    6774                                        DspinDhccpParam::CLEANUP_DATA_UPDT);
     6767                                       DspinHmesiParam::CLEANUP_DATA_UPDT);
    67756768           
    67766769            p_dspin_p2m.data = dspin_send_data;
     
    67846777        {
    67856778            // initialize dspin send data
    6786             DspinDhccpParam::dspin_set(dspin_send_data,
     6779            DspinHmesiParam::dspin_set(dspin_send_data,
    67876780                                       0,
    6788                                        DspinDhccpParam::P2M_BC);
    6789             DspinDhccpParam::dspin_set(dspin_send_data,
    6790                                        DspinDhccpParam::TYPE_MULTI_ACK,
    6791                                        DspinDhccpParam::P2M_TYPE);
     6781                                       DspinHmesiParam::P2M_BC);
     6782            DspinHmesiParam::dspin_set(dspin_send_data,
     6783                                       DspinHmesiParam::TYPE_MULTI_ACK,
     6784                                       DspinHmesiParam::P2M_TYPE);
    67926785
    67936786            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    67956788                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
    67966789                                >> (m_nline_width - m_x_width - m_y_width)
    6797                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6790                                << (DspinHmesiParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    67986791 
    6799                 DspinDhccpParam::dspin_set(dspin_send_data,
     6792                DspinHmesiParam::dspin_set(dspin_send_data,
    68006793                                           dest,
    6801                                            DspinDhccpParam::MULTI_ACK_DEST);
    6802 
    6803                 DspinDhccpParam::dspin_set(dspin_send_data,
     6794                                           DspinHmesiParam::MULTI_ACK_DEST);
     6795
     6796                DspinHmesiParam::dspin_set(dspin_send_data,
    68046797                                           r_dcache_cc_send_multi_ack_miss.read(),
    6805                                            DspinDhccpParam::MULTI_ACK_UPDT_MISS);
    6806 
    6807                 DspinDhccpParam::dspin_set(dspin_send_data,
     6798                                           DspinHmesiParam::MULTI_ACK_UPDT_MISS);
     6799
     6800                DspinHmesiParam::dspin_set(dspin_send_data,
    68086801                                           r_dcache_cc_send_updt_tab_idx.read(),
    6809                                            DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
     6802                                           DspinHmesiParam::MULTI_ACK_UPDT_INDEX);
    68106803            }
    68116804            else                                    // icache active request
     
    68136806                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
    68146807                                >> (m_nline_width - m_x_width - m_y_width)
    6815                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6808                                << (DspinHmesiParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    68166809 
    6817                 DspinDhccpParam::dspin_set(dspin_send_data,
     6810                DspinHmesiParam::dspin_set(dspin_send_data,
    68186811                                           dest,
    6819                                            DspinDhccpParam::MULTI_ACK_DEST);
    6820 
    6821                 DspinDhccpParam::dspin_set(dspin_send_data,
     6812                                           DspinHmesiParam::MULTI_ACK_DEST);
     6813
     6814                DspinHmesiParam::dspin_set(dspin_send_data,
    68226815                                           r_icache_cc_send_updt_tab_idx.read(),
    6823                                            DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
     6816                                           DspinHmesiParam::MULTI_ACK_UPDT_INDEX);
    68246817            }
    68256818            // send flit
     
    69136906
    69146907
    6915     int clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
    6916                                                 DspinDhccpParam::CLACK_TYPE);
     6908    int clack_type = DspinHmesiParam::dspin_get(r_dspin_clack_flit.read(),
     6909                                                DspinHmesiParam::CLACK_TYPE);
    69176910
    69186911    bool dspin_clack_get      = false;
    6919     bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA);
    6920     bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST);
     6912    bool dcache_clack_request = (clack_type == DspinHmesiParam::TYPE_CLACK_DATA);
     6913    bool icache_clack_request = (clack_type == DspinHmesiParam::TYPE_CLACK_INST);
    69216914
    69226915    if (r_dspin_clack_req.read())
  • branches/MESI/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd

    r670 r785  
    4040            Uses('caba:generic_fifo'),
    4141            Uses('caba:generic_llsc_global_table'),
    42             Uses('caba:dspin_dhccp_param')
     42            Uses('caba:dspin_hmesi_param')
    4343        ],
    4444
  • branches/MESI/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r719 r785  
    3838#include <list>
    3939#include <cassert>
     40
    4041#include "arithmetics.h"
    4142#include "alloc_elems.h"
     
    5152#include "update_tab.h"
    5253#include "dspin_interface.h"
    53 #include "dspin_dhccp_param.h"
     54#include "dspin_hmesi_param.h"
    5455
    5556#define TRT_ENTRIES      4      // Number of entries in TRT
     
    6970    : public soclib::caba::BaseModule
    7071    {
    71       typedef typename vci_param_int::fast_addr_t  addr_t;
    72       typedef typename sc_dt::sc_uint<64>          wide_data_t;
    73       typedef uint32_t                             data_t;
    74       typedef uint32_t                             tag_t;
    75       typedef uint32_t                             be_t;
    76       typedef uint32_t                             copy_t;
     72      typedef typename vci_param_int::fast_addr_t addr_t;
     73      typedef typename sc_dt::sc_uint<64>         wide_data_t;
     74      typedef uint32_t                            data_t;
     75      typedef uint32_t                            tag_t;
     76      typedef uint32_t                            be_t;
     77      typedef uint32_t                            copy_t;
    7778
    7879      /* States of the TGT_CMD fsm */
     
    392393          //  b1 accÚs table llsc type SW / other
    393394          //  b2 WRITE/CAS/LL/SC
    394           TYPE_DATA_UNC               = 0x0,
    395           TYPE_READ_DATA_MISS         = 0x1,
    396           TYPE_READ_INS_UNC           = 0x2,
    397           TYPE_READ_INS_MISS          = 0x3,
    398           TYPE_WRITE                  = 0x4,
    399           TYPE_CAS                    = 0x5,
    400           TYPE_LL                     = 0x6,
    401           TYPE_SC                     = 0x7
     395          TYPE_DATA_UNC       = 0x0,
     396          TYPE_READ_DATA_MISS = 0x1,
     397          TYPE_READ_INS_UNC   = 0x2,
     398          TYPE_READ_INS_MISS  = 0x3,
     399          TYPE_WRITE          = 0x4,
     400          TYPE_CAS            = 0x5,
     401          TYPE_LL             = 0x6,
     402          TYPE_SC             = 0x7
    402403      };
    403404
     
    405406      enum sc_status_type_e
    406407      {
    407           SC_SUCCESS  =  0x00000000,
    408           SC_FAIL     =  0x00000001
     408          SC_SUCCESS = 0x00000000,
     409          SC_FAIL    = 0x00000001
    409410      };
    410411
    411412      // debug variables
    412       bool                 m_debug;
    413       size_t               m_debug_previous_valid;
    414       size_t               m_debug_previous_count;
    415       bool                 m_debug_previous_dirty;
    416       data_t *             m_debug_previous_data;
    417       data_t *             m_debug_data;
     413      bool     m_debug;
     414      size_t   m_debug_previous_valid;
     415      size_t   m_debug_previous_count;
     416      bool     m_debug_previous_dirty;
     417      data_t * m_debug_previous_data;
     418      data_t * m_debug_data;
    418419
    419420      // instrumentation counters
    420       uint32_t     m_cpt_cycles;        // Counter of cycles
    421 
    422       // Counters accessible in software (not yet but eventually)
    423       uint32_t     m_cpt_reset_count;    // Last cycle at which counters have been reset
    424       uint32_t     m_cpt_read_miss_local;     // Number of local READ transactions
    425       uint32_t     m_cpt_read_miss_remote;    // number of remote READ transactions
    426       uint32_t     m_cpt_read_miss_cost;      // Number of (flits * distance) for READs
    427 
    428       uint32_t     m_cpt_getm_miss_local;     // Number of local getm miss  transactions
    429       uint32_t     m_cpt_getm_miss_remote;    // number of remote getm miss transactions
    430 
    431       uint32_t     m_cpt_getm_hit_local;     // Number of local getm hit transactions
    432       uint32_t     m_cpt_getm_hit_remote;    // number of remote getm hit transactions
    433       uint32_t     m_cpt_getm_cost;          // Number of (flits * distance) for getm
    434 
    435       uint32_t     m_cpt_write_local;    // Number of local WRITE transactions
    436       uint32_t     m_cpt_write_remote;   // number of remote WRITE transactions
    437       uint32_t     m_cpt_write_flits_local;  // number of flits for local WRITEs
    438       uint32_t     m_cpt_write_flits_remote; // number of flits for remote WRITEs
    439       uint32_t     m_cpt_write_cost;     // Number of (flits * distance) for WRITEs
    440 
    441       uint32_t     m_cpt_ll_local;       // Number of local LL transactions
    442       uint32_t     m_cpt_ll_remote;      // number of remote LL transactions
    443       uint32_t     m_cpt_ll_cost;        // Number of (flits * distance) for LLs
    444 
    445       uint32_t     m_cpt_sc_local;       // Number of local SC transactions
    446       uint32_t     m_cpt_sc_remote;      // number of remote SC transactions
    447       uint32_t     m_cpt_sc_cost;        // Number of (flits * distance) for SCs
    448 
    449       uint32_t     m_cpt_cas_local;      // Number of local SC transactions
    450       uint32_t     m_cpt_cas_remote;     // number of remote SC transactions
    451       uint32_t     m_cpt_cas_cost;       // Number of (flits * distance) for SCs
    452 
    453       uint32_t     m_cpt_update;         // Number of requests causing an UPDATE
    454       uint32_t     m_cpt_update_local;   // Number of local UPDATE transactions
    455       uint32_t     m_cpt_update_remote;  // Number of remote UPDATE transactions
    456       uint32_t     m_cpt_update_cost;    // Number of (flits * distance) for UPDT
    457 
    458       uint32_t     m_cpt_minval;         // Number of requests causing M_INV
    459       uint32_t     m_cpt_minval_local;   // Number of local M_INV transactions
    460       uint32_t     m_cpt_minval_remote;  // Number of remote M_INV transactions
    461       uint32_t     m_cpt_minval_cost;    // Number of (flits * distance) for M_INV
    462 
    463       uint32_t     m_cpt_binval;         // Number of BROADCAST INVAL
    464 
    465       uint32_t     m_cpt_cleanup_local;  // Number of local CLEANUP transactions
    466       uint32_t     m_cpt_cleanup_remote; // Number of remote CLEANUP transactions
    467       uint32_t     m_cpt_cleanup_with_data;
    468       uint32_t     m_cpt_cleanup_cost;   // Number of (flits * distance) for CLEANUPs
    469 
    470       uint32_t     m_cpt_multi_ack_miss;  // Number of local CLEANUP transactions
    471       uint32_t     m_cpt_multi_ack_hit;   // Number of local CLEANUP transactions
    472       uint32_t     m_cpt_multi_ack_hit_with_data; // Number of remote CLEANUP transactions
     421      uint32_t m_cpt_cycles;        // Counter of cycles
     422
     423      // Counters
     424      // (*) = Counters accessible in software
     425      uint32_t m_cpt_reset_count;    // Last cycle at which counters have been reset
     426
     427      uint32_t m_cpt_read_local;     // Number of local READ transactions (*)
     428      uint32_t m_cpt_read_remote;    // number of remote READ transactions (*)
     429      uint32_t m_cpt_read_cost;      // Number of (flits * distance) for READs (*)
     430
     431      uint32_t m_cpt_write_local;    // Number of local WRITE transactions
     432      uint32_t m_cpt_write_remote;   // number of remote WRITE transactions
     433      uint32_t m_cpt_write_flits_local;  // number of flits for local WRITEs (*)
     434      uint32_t m_cpt_write_flits_remote; // number of flits for remote WRITEs (*)
     435      uint32_t m_cpt_write_cost;     // Number of (flits * distance) for WRITEs (*)
     436
     437      uint32_t m_cpt_ll_local;       // Number of local LL transactions (*)
     438      uint32_t m_cpt_ll_remote;      // number of remote LL transactions (*)
     439      uint32_t m_cpt_ll_cost;        // Number of (flits * distance) for LLs (*)
     440
     441      uint32_t m_cpt_sc_local;       // Number of local SC transactions (*)
     442      uint32_t m_cpt_sc_remote;      // number of remote SC transactions (*)
     443      uint32_t m_cpt_sc_cost;        // Number of (flits * distance) for SCs (*)
     444
     445      uint32_t m_cpt_cas_local;      // Number of local SC transactions (*)
     446      uint32_t m_cpt_cas_remote;     // number of remote SC transactions (*)
     447      uint32_t m_cpt_cas_cost;       // Number of (flits * distance) for SCs (*)
     448
     449      uint32_t m_cpt_minval;         // Number of requests causing M_INV (*)
     450      uint32_t m_cpt_minval_local;   // Number of local M_INV transactions (*)
     451      uint32_t m_cpt_minval_remote;  // Number of remote M_INV transactions (*)
     452      uint32_t m_cpt_minval_cost;    // Number of (flits * distance) for M_INV (*)
     453
     454      uint32_t m_cpt_binval;         // Number of BROADCAST INVAL (*)
     455      uint32_t m_cpt_write_broadcast;// Number of BROADCAST INVAL caused by write
     456      uint32_t m_cpt_getm_broadcast; // Number of BROADCAST INVAL caused by getm
     457
     458      uint32_t m_cpt_cleanup_local;  // Number of local CLEANUP transactions (*)
     459      uint32_t m_cpt_cleanup_remote; // Number of remote CLEANUP transactions (*)
     460      uint32_t m_cpt_cleanup_cost;   // Number of (flits * distance) for CLEANUPs (*)
     461      uint32_t m_cpt_cleanup_data_local; //
     462      uint32_t m_cpt_cleanup_data_remote; //
     463      uint32_t m_cpt_cleanup_data_cost; //
     464
     465      uint32_t m_cpt_read_miss;      // Number of MISS READ
     466      uint32_t m_cpt_write_miss;     // Number of MISS WRITE
     467      uint32_t m_cpt_write_dirty;    // Cumulated length for WRITE transactions
     468      uint32_t m_cpt_getm_miss;      // Number of getm miss
     469
     470      uint32_t m_cpt_getm_local;     // Number of local getm miss  transactions
     471      uint32_t m_cpt_getm_remote;    // number of remote getm miss transactions
     472      uint32_t m_cpt_getm_cost;      // Number of (flits * distance) for getm
     473
     474      uint32_t m_cpt_inval_ro_local;  // Number of local INVAL RO (*)
     475      uint32_t m_cpt_inval_ro_remote; // Number of local INVAL RO (*)
     476      uint32_t m_cpt_inval_ro_cost;   // Cost for INVAL RO (*)
    473477   
    474       // Counters not accessible by software
    475       uint32_t     m_cpt_read_miss;      // Number of MISS READ
    476       uint32_t     m_cpt_getm_miss;      // Number of getm miss
    477       uint32_t     m_cpt_getm_broadcast; // Number of BROADCAST INVAL because getm
    478       uint32_t     m_cpt_getm_minval;    // Number of MULTI INVAL because getm
    479       uint32_t     m_cpt_write_miss;     // Number of MISS WRITE
    480       uint32_t     m_cpt_write_dirty;    // Cumulated length for WRITE transactions
    481       uint32_t     m_cpt_write_broadcast;// Number of BROADCAST INVAL because write
    482       uint32_t     m_cpt_write_minval;   // Number of MULTI INVAL because write
    483       uint32_t     m_cpt_cas_broadcast;  // Number of BROADCAST INVAL because cas
    484       uint32_t     m_cpt_cas_minval;     // Number of MULTI INVAL because cas
    485       uint32_t     m_cpt_cas_miss;
    486 
    487       uint32_t     m_cpt_read_locked_rb; // Read blocked by a locked ligne
    488       uint32_t     m_cpt_cas_locked_rb;       // cas  blocked by a locked ligne
    489       uint32_t     m_cpt_write_locked_rb;     // wt   blocked by a locked ligne
    490 
    491       uint32_t     m_cpt_trt_rb;        // Read blocked by a hit in trt
    492       uint32_t     m_cpt_trt_full;      // Transaction blocked due to a full trt
    493       uint32_t     m_cpt_put;     
    494       uint32_t     m_cpt_get;
    495      
    496       uint32_t     m_cpt_read_fsm_dir_lock;        // wait DIR LOCK
    497       uint32_t     m_cpt_read_fsm_n_dir_lock;      // NB DIR LOCK
    498       uint32_t     m_cpt_write_fsm_dir_lock;       // wait DIR LOCK
    499       uint32_t     m_cpt_write_fsm_n_dir_lock;     // NB DIR LOCK
    500       uint32_t     m_cpt_xram_rsp_fsm_dir_lock;    // wait DIR LOCK
    501       uint32_t     m_cpt_xram_rsp_fsm_n_dir_lock;  // NB DIR LOCK
    502       uint32_t     m_cpt_cas_fsm_dir_lock;         // wait DIR LOCK
    503       uint32_t     m_cpt_cas_fsm_n_dir_lock;       // NB DIR LOCK
    504       uint32_t     m_cpt_cleanup_fsm_dir_lock;     // wait DIR LOCK
    505       uint32_t     m_cpt_cleanup_fsm_n_dir_lock;   // NB DIR LOCK
    506       uint32_t     m_cpt_multi_ack_fsm_dir_lock;     // wait DIR LOCK
    507       uint32_t     m_cpt_multi_ack_fsm_n_dir_lock;   // NB DIR LOCK
    508 
    509       uint32_t     m_cpt_dir_unused;            // NB cycles DIR LOCK unused
    510       uint32_t     m_cpt_read_fsm_dir_used;     // NB cycles DIR LOCK used
    511       uint32_t     m_cpt_write_fsm_dir_used;    // NB cycles DIR LOCK used
    512       uint32_t     m_cpt_cas_fsm_dir_used;      // NB cycles DIR LOCK used
    513       uint32_t     m_cpt_xram_rsp_fsm_dir_used; // NB cycles DIR LOCK used
    514       uint32_t     m_cpt_cleanup_fsm_dir_used;  // NB cycles DIR LOCK used
    515       uint32_t     m_cpt_multi_ack_fsm_dir_used;  // NB cycles DIR LOCK used
    516 
    517       uint32_t     m_cpt_read_fsm_trt_lock;      // wait TRT LOCK
    518       uint32_t     m_cpt_write_fsm_trt_lock;     // wait TRT LOCK
    519       uint32_t     m_cpt_cas_fsm_trt_lock;       // wait TRT LOCK
    520       uint32_t     m_cpt_xram_rsp_fsm_trt_lock;  // wait TRT LOCK
    521       uint32_t     m_cpt_ixr_fsm_trt_lock;       // wait TRT LOCK
    522      
    523       uint32_t     m_cpt_read_fsm_n_trt_lock;      // NB TRT LOCK
    524       uint32_t     m_cpt_write_fsm_n_trt_lock;     // NB TRT LOCK
    525       uint32_t     m_cpt_cas_fsm_n_trt_lock;       // NB TRT LOCK
    526       uint32_t     m_cpt_xram_rsp_fsm_n_trt_lock;  // NB TRT LOCK
    527       uint32_t     m_cpt_ixr_cmd_fsm_n_trt_lock;   // NB TRT LOCK
    528       uint32_t     m_cpt_ixr_rsp_fsm_n_trt_lock;   // NB TRT LOCK
    529 
    530       uint32_t     m_cpt_read_fsm_trt_used;      // NB cycles TRT LOCK used
    531       uint32_t     m_cpt_write_fsm_trt_used;     // NB cycles TRT LOCK used
    532       uint32_t     m_cpt_cas_fsm_trt_used;       // NB cycles TRT LOCK used
    533       uint32_t     m_cpt_xram_rsp_fsm_trt_used;  // NB cycles TRT LOCK used
    534       uint32_t     m_cpt_ixr_cmd_fsm_trt_used;   // NB cycles TRT LOCK used
    535       uint32_t     m_cpt_ixr_rsp_fsm_trt_used;   // NB cycles TRT LOCK used
    536       uint32_t     m_cpt_cleanup_fsm_trt_used;   // NB cycles TRT LOCK used
    537      
    538       uint32_t     m_cpt_trt_unused;            // NB cycles TRT LOCK unused
    539 
    540       uint32_t     m_cpt_cleanup_fsm_ivt_lock;   // wait ivt LOCK
    541       uint32_t     m_cpt_cleanup_fsm_n_ivt_lock;   // NB cycles UPT LOCK used
    542      
    543       uint32_t     m_cpt_multi_ack_fsm_ivt_lock;   // wait ivt LOCK
    544       uint32_t     m_cpt_multi_ack_fsm_n_ivt_lock;   // NB cycles UPT LOCK used
    545 
    546       uint32_t     m_cpt_ivt_unused;            // NB cycles UPT LOCK unused
    547 
    548       uint32_t     m_cpt_read_fsm_heap_lock;     // wait HEAP LOCK
    549       uint32_t     m_cpt_write_fsm_heap_lock;    // wait HEAP LOCK
    550       uint32_t     m_cpt_cas_fsm_heap_lock;      // wait HEAP LOCK
    551       uint32_t     m_cpt_cleanup_fsm_heap_lock;  // wait HEAP LOCK
    552       uint32_t     m_cpt_xram_rsp_fsm_heap_lock; // wait HEAP LOCK
    553       uint32_t     m_cpt_multi_ack_fsm_heap_lock; // wait HEAP LOCK
    554      
    555       uint32_t     m_cpt_read_fsm_n_heap_lock;     // NB HEAP LOCK
    556       uint32_t     m_cpt_write_fsm_n_heap_lock;    // NB HEAP LOCK
    557       uint32_t     m_cpt_cas_fsm_n_heap_lock;      // NB HEAP LOCK
    558       uint32_t     m_cpt_cleanup_fsm_n_heap_lock;  // NB HEAP LOCK
    559       uint32_t     m_cpt_xram_rsp_fsm_n_heap_lock; // NB HEAP LOCK
    560       uint32_t     m_cpt_multi_ack_fsm_n_heap_lock; // NB HEAP LOCK
    561      
    562       uint32_t     m_cpt_read_fsm_heap_used;     // NB cycles HEAP LOCK used
    563       uint32_t     m_cpt_write_fsm_heap_used;    // NB cycles HEAP LOCK used
    564       uint32_t     m_cpt_cas_fsm_heap_used;      // NB cycles HEAP LOCK used
    565       uint32_t     m_cpt_cleanup_fsm_heap_used;  // NB cycles HEAP LOCK used
    566       uint32_t     m_cpt_xram_rsp_fsm_heap_used; // NB cycles HEAP LOCK used
    567       uint32_t     m_cpt_multi_ack_fsm_heap_used; // NB cycles HEAP LOCK used
    568      
    569       uint32_t     m_cpt_heap_unused;            // NB cycles HEAP LOCK unused
    570       uint32_t     m_cpt_slot_inval;           
     478      uint32_t m_cpt_trt_rb;         // Read blocked by a hit in trt
     479      uint32_t m_cpt_trt_full;       // Transaction blocked due to a full trt
     480      uint32_t m_cpt_put;     
     481      uint32_t m_cpt_get;
     482           
     483      uint32_t m_cpt_heap_unused;    // NB cycles HEAP LOCK unused
     484      uint32_t m_cpt_slot_inval;           
    571485
    572486      protected:
     
    602516      sc_out<int> p_cc_send_fsm;
    603517      sc_out<int> p_cc_receive_fsm;
    604       sc_out<int> p_multi_ack_fsm; 
     518      sc_out<int> p_multi_ack_fsm;
    605519#endif
    606520
     
    611525          const soclib::common::IntTab       &srcid_x,        // global index RAM network
    612526          const soclib::common::IntTab       &tgtid_d,        // global index INT network
    613           const size_t                       cc_global_id,    // global index CC network
    614527          const size_t                       x_width,         // X width in platform
    615528          const size_t                       y_width,         // Y width in platform
     
    654567      const size_t                       m_sets;             // Number of cache sets
    655568      const size_t                       m_words;            // Number of words in a line
    656       const size_t                       m_cc_global_id;     // global_index on cc network
    657       const size_t                       m_xwidth;           // number of x bits in platform
    658       const size_t                       m_ywidth;           // number of y bits in platform
     569      size_t                             m_x_self;           // X self coordinate
     570      size_t                             m_y_self;           // Y self coordinate
     571      const size_t                       m_x_width;          // number of x bits in platform
     572      const size_t                       m_y_width;          // number of y bits in platform
    659573      size_t                             m_debug_start_cycle;
    660574      bool                               m_debug_ok;
  • branches/MESI/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r719 r785  
    351351            const IntTab        &srcid_x,          // global index on external network
    352352            const IntTab        &tgtid_d,          // global index on direct network
    353             const size_t        cc_global_id,      // global index on cc network
    354353            const size_t        x_width,           // number of x bits in platform
    355354            const size_t        y_width,           // number of x bits in platform
     
    384383        m_sets( nsets ),
    385384        m_words( nwords ),
    386         m_cc_global_id( cc_global_id ),
    387         m_xwidth(x_width),
    388         m_ywidth(y_width),
     385        m_x_width(x_width),
     386        m_y_width(y_width),
    389387        m_debug_start_cycle( debug_start_cycle ),
    390388        m_debug_ok( debug_ok ),
     
    550548            for(seg = m_seglist.begin() ; seg != m_seglist.end() ; seg++)
    551549            {
    552                 if ( seg->special() ) m_seg_config = i;
     550                if (seg->special() ) m_seg_config = i;
    553551                m_seg[i] = & (*seg);
    554552                i++;
    555553            }
     554
     555            addr_t gid = m_seg[0]->baseAddress() >> (vci_param_int::N - x_width - y_width);
     556            m_x_self = (gid >> m_y_width) & ((1 << m_x_width) - 1);
     557            m_y_self =  gid               & ((1 << m_y_width) - 1);
    556558
    557559            // Allocation for IXR_RSP FSM
     
    614616        bool data_change = false;
    615617
    616         if ( entry.state != ENTRY_INVALID )
     618        if (entry.state != ENTRY_INVALID )
    617619        {
    618620            for ( size_t word = 0 ; word<m_words ; word++ )
    619621            {
    620622                m_debug_data[word] = m_cache_data.read(way, set, word);
    621                 if ( (m_debug_previous_valid != ENTRY_INVALID) and
     623                if ((m_debug_previous_valid != ENTRY_INVALID) and
    622624                        (m_debug_data[word] != m_debug_previous_data[word]) )
    623625                {
     
    628630
    629631        // print values if any change
    630         if ( (entry.state != m_debug_previous_valid) or
     632        if ((entry.state != m_debug_previous_valid) or
    631633                ((entry.state != ENTRY_INVALID) and (entry.count != m_debug_previous_count)) or
    632634                ((entry.state != ENTRY_INVALID) and (entry.dirty != m_debug_previous_dirty)) or data_change )
     
    672674    {
    673675        const uint32_t srcid_width = vci_param_int::S;
    674         uint8_t self_x_srcid = m_cc_global_id >> (srcid_width - m_xwidth);
    675         uint8_t self_y_srcid = (m_cc_global_id >> (srcid_width - m_ywidth)) & ((1 << m_xwidth) - 1);
    676 
    677         uint8_t x_srcid = req_srcid >> (srcid_width - m_xwidth);
    678         uint8_t y_srcid = (req_srcid >> (srcid_width - m_ywidth - m_xwidth)) & ((1 << m_xwidth) - 1);
    679         return abs(self_x_srcid - x_srcid) + abs(self_y_srcid - y_srcid);
     676
     677        uint8_t req_x = (req_srcid >> (srcid_width - m_x_width));
     678        uint8_t req_y = (req_srcid >> (srcid_width - m_x_width - m_y_width)) & ((1 << m_y_width) - 1);
     679
     680        return abs(m_x_self - req_x) + abs(m_y_self - req_y);
    680681    }
    681682
     
    706707            // LOCAL
    707708
    708             case MEMC_LOCAL_READ_LO   : rdata = m_cpt_read_miss_local   ; break;
     709            case MEMC_LOCAL_READ_LO   : rdata = m_cpt_read_local   ; break;
    709710            case MEMC_LOCAL_WRITE_LO  : rdata = m_cpt_write_flits_local ; break;
    710711            case MEMC_LOCAL_LL_LO     : rdata = m_cpt_ll_local          ; break;
     
    719720            // REMOTE
    720721
    721             case MEMC_REMOTE_READ_LO  : rdata = m_cpt_read_miss_remote   ; break;
     722            case MEMC_REMOTE_READ_LO  : rdata = m_cpt_read_remote   ; break;
    722723            case MEMC_REMOTE_WRITE_LO : rdata = m_cpt_write_flits_remote ; break;
    723724            case MEMC_REMOTE_LL_LO    : rdata = m_cpt_ll_remote          ; break;
     
    732733            // COST
    733734
    734             case MEMC_COST_READ_LO    : rdata = m_cpt_read_miss_cost ; break;
     735            case MEMC_COST_READ_LO    : rdata = m_cpt_read_cost ; break;
    735736            case MEMC_COST_WRITE_LO   : rdata = m_cpt_write_cost; break;
    736737            case MEMC_COST_LL_LO      : rdata = m_cpt_ll_cost   ; break;
     
    753754            // LOCAL
    754755
    755             case MEMC_LOCAL_MUPDATE_LO  : rdata = m_cpt_update_local ; break;
    756             case MEMC_LOCAL_MINVAL_LO   : rdata = m_cpt_minval_local ; break;
    757             case MEMC_LOCAL_CLEANUP_LO  : rdata = m_cpt_cleanup_local; break;
     756            case MEMC_LOCAL_MUPDATE_LO  : rdata = m_cpt_inval_ro_local; break;
     757            case MEMC_LOCAL_MINVAL_LO   : rdata = m_cpt_minval_local ;  break;
     758            case MEMC_LOCAL_CLEANUP_LO  : rdata = m_cpt_cleanup_local;  break;
    758759            case MEMC_LOCAL_MUPDATE_HI  :
    759760            case MEMC_LOCAL_MINVAL_HI   :
     
    762763            // REMOTE
    763764
    764             case MEMC_REMOTE_MUPDATE_LO : rdata = m_cpt_update_remote ; break;
    765             case MEMC_REMOTE_MINVAL_LO  : rdata = m_cpt_minval_remote ; break;
    766             case MEMC_REMOTE_CLEANUP_LO : rdata = m_cpt_cleanup_remote; break;
     765            case MEMC_REMOTE_MUPDATE_LO : rdata = m_cpt_inval_ro_remote; break;
     766            case MEMC_REMOTE_MINVAL_LO  : rdata = m_cpt_minval_remote ;  break;
     767            case MEMC_REMOTE_CLEANUP_LO : rdata = m_cpt_cleanup_remote;  break;
    767768            case MEMC_REMOTE_MUPDATE_HI :
    768769            case MEMC_REMOTE_MINVAL_HI  :
     
    771772            // COST
    772773
    773             case MEMC_COST_MUPDATE_LO   : rdata = m_cpt_update_cost   ; break;
    774             case MEMC_COST_MINVAL_LO    : rdata = m_cpt_minval_cost   ; break;
    775             case MEMC_COST_CLEANUP_LO   : rdata = m_cpt_cleanup_cost  ; break;
     774            case MEMC_COST_MUPDATE_LO   : rdata = m_cpt_inval_ro_cost; break;
     775            case MEMC_COST_MINVAL_LO    : rdata = m_cpt_minval_cost break;
     776            case MEMC_COST_CLEANUP_LO   : rdata = m_cpt_cleanup_cost; break;
    776777            case MEMC_COST_MUPDATE_HI   :
    777778            case MEMC_COST_MINVAL_HI    :
     
    779780
    780781            // TOTAL
    781 
    782             case MEMC_TOTAL_MUPDATE_LO  : rdata = m_cpt_update ; break;
    783             case MEMC_TOTAL_MINVAL_LO   : rdata = m_cpt_minval ; break;
    784             case MEMC_TOTAL_BINVAL_LO   : rdata = m_cpt_binval ; break;
     782            // inval_ro are equal to the number of requests triggering them
     783            case MEMC_TOTAL_MUPDATE_LO  : rdata = m_cpt_inval_ro_local + m_cpt_inval_ro_remote; break;
     784            case MEMC_TOTAL_MINVAL_LO   : rdata = m_cpt_minval ;  break;
     785            case MEMC_TOTAL_BINVAL_LO   : rdata = m_cpt_binval ;  break;
    785786            case MEMC_TOTAL_MUPDATE_HI  :
    786787            case MEMC_TOTAL_MINVAL_HI   :
     
    788789
    789790            // unknown register
    790 
    791791            default                     : error = 1;
    792792        }
     
    819819            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
    820820
    821         if ( detailed ) m_trt.print(0);
     821        if (detailed ) m_trt.print(0);
    822822    }
    823823
     
    827827    /////////////////////////////////////////
    828828    {
    829         m_cpt_reset_count        = m_cpt_cycles;
    830 
    831         m_cpt_read_miss_local           = 0 ;
    832         m_cpt_read_miss_remote          = 0 ;
    833         m_cpt_read_miss_cost            = 0 ;     
    834                                                                                  
    835         m_cpt_getm_miss_local           = 0 ;     
    836         m_cpt_getm_miss_remote          = 0 ;     
    837                                                                                          
    838         m_cpt_getm_hit_local            = 0 ;     
    839         m_cpt_getm_hit_remote           = 0 ;         
    840         m_cpt_getm_cost                 = 0 ;
    841                                                                                              
    842         m_cpt_write_local               = 0 ;     
    843         m_cpt_write_remote              = 0 ;     
    844         m_cpt_write_flits_local         = 0 ;         
    845         m_cpt_write_flits_remote        = 0 ;         
    846         m_cpt_write_cost                = 0 ;   
    847 
    848         m_cpt_ll_local                  = 0 ;         
    849         m_cpt_ll_remote                 = 0 ;             
    850         m_cpt_ll_cost                   = 0 ;         
    851                                                                                            
    852         m_cpt_sc_local                  = 0 ;                             
    853         m_cpt_sc_remote                 = 0 ;                             
    854         m_cpt_sc_cost                   = 0 ;                             
    855                                                                                          
    856         m_cpt_cas_local                 = 0 ;                                 
    857         m_cpt_cas_remote                = 0 ;                                     
    858         m_cpt_cas_cost                  = 0 ;                                 
    859                                                                                      
    860         m_cpt_update                    = 0 ;                     
    861         m_cpt_update_local              = 0 ;                             
    862         m_cpt_update_remote             = 0 ;                             
    863         m_cpt_update_cost               = 0 ;                         
    864                                                                                    
    865         m_cpt_minval                    = 0 ;                 
    866         m_cpt_minval_local              = 0 ;                         
    867         m_cpt_minval_remote             = 0 ;                     
    868         m_cpt_minval_cost               = 0 ;                         
    869                                                                                      
    870         m_cpt_binval                    = 0 ;                     
    871                                                                                              
    872         m_cpt_cleanup_local             = 0 ;                             
    873         m_cpt_cleanup_remote            = 0 ;                         
    874         m_cpt_cleanup_with_data         = 0 ;                             
    875         m_cpt_cleanup_cost              = 0 ;                         
    876                                                                                      
    877         m_cpt_multi_ack_miss            = 0 ;                         
    878         m_cpt_multi_ack_hit             = 0 ;                     
    879         m_cpt_multi_ack_hit_with_data   = 0 ;                             
    880                                                                                      
    881                                                  
    882         m_cpt_read_miss                 = 0 ;                                     
    883         m_cpt_getm_miss                 = 0 ;                                 
    884         m_cpt_getm_broadcast            = 0 ;                                     
    885         m_cpt_getm_minval               = 0 ;                                     
    886         m_cpt_write_miss                = 0 ;                                             
    887         m_cpt_write_dirty               = 0 ;                                             
    888         m_cpt_write_broadcast           = 0 ;                                                 
    889         m_cpt_write_minval              = 0 ;                                         
    890         m_cpt_cas_broadcast             = 0 ;                                                 
    891         m_cpt_cas_minval                = 0 ;                                                                 
    892         m_cpt_cas_miss                  = 0 ;                                                 
    893                                                                                      
    894         m_cpt_read_locked_rb            = 0 ;                                                                 
    895         m_cpt_cas_locked_rb             = 0 ;                                                                 
    896         m_cpt_write_locked_rb           = 0 ;                                                                                             
    897                                                                                      
    898         m_cpt_trt_rb                    = 0 ;                                                                 
    899         m_cpt_trt_full                  = 0 ;                                                             
    900         m_cpt_put                       = 0 ;                                                             
    901         m_cpt_get                       = 0 ;                                                             
    902         m_cpt_read_fsm_dir_lock         = 0 ;                                                                         
    903         m_cpt_read_fsm_n_dir_lock       = 0 ;                                                                         
    904         m_cpt_write_fsm_dir_lock        = 0 ;                                                                 
    905         m_cpt_write_fsm_n_dir_lock      = 0 ;                                                                                         
    906         m_cpt_xram_rsp_fsm_dir_lock     = 0 ;                                                                             
    907         m_cpt_xram_rsp_fsm_n_dir_lock   = 0 ;                                                                 
    908         m_cpt_cas_fsm_dir_lock          = 0 ;                                                         
    909         m_cpt_cas_fsm_n_dir_lock        = 0 ;                                             
    910         m_cpt_cleanup_fsm_dir_lock      = 0 ;                                                         
    911         m_cpt_cleanup_fsm_n_dir_lock    = 0 ;                                                     
    912         m_cpt_multi_ack_fsm_dir_lock    = 0 ;                                                 
    913         m_cpt_multi_ack_fsm_n_dir_lock  = 0 ;                                                     
    914                                                                                        
    915         m_cpt_dir_unused                = 0 ;                                                             
    916         m_cpt_read_fsm_dir_used         = 0 ;                                                             
    917         m_cpt_write_fsm_dir_used        = 0 ;                                                     
    918         m_cpt_cas_fsm_dir_used          = 0 ;                                             
    919         m_cpt_xram_rsp_fsm_dir_used     = 0 ;                                                 
    920         m_cpt_cleanup_fsm_dir_used      = 0 ;                                                 
    921         m_cpt_multi_ack_fsm_dir_used    = 0 ;                                                         
    922                                                                                                                    
    923         m_cpt_read_fsm_trt_lock         = 0 ;                                                 
    924         m_cpt_write_fsm_trt_lock        = 0 ;                                                         
    925         m_cpt_cas_fsm_trt_lock          = 0 ;                                                         
    926         m_cpt_xram_rsp_fsm_trt_lock     = 0 ;                                                     
    927         m_cpt_ixr_fsm_trt_lock          = 0 ;                                                     
    928                                                                                      
    929         m_cpt_read_fsm_n_trt_lock       = 0 ;                                             
    930         m_cpt_write_fsm_n_trt_lock      = 0 ;                                                         
    931         m_cpt_cas_fsm_n_trt_lock        = 0 ;                                                     
    932         m_cpt_xram_rsp_fsm_n_trt_lock   = 0 ;                                         
    933         m_cpt_ixr_cmd_fsm_n_trt_lock    = 0 ;                                                             
    934         m_cpt_ixr_rsp_fsm_n_trt_lock    = 0 ;                                                     
    935                                                                                      
    936         m_cpt_read_fsm_trt_used         = 0 ;                                                     
    937         m_cpt_write_fsm_trt_used        = 0 ;                                                         
    938         m_cpt_cas_fsm_trt_used          = 0 ;                                             
    939         m_cpt_xram_rsp_fsm_trt_used     = 0 ;                                                     
    940         m_cpt_ixr_cmd_fsm_trt_used      = 0 ;                                                 
    941         m_cpt_ixr_rsp_fsm_trt_used      = 0 ;                                                     
    942         m_cpt_cleanup_fsm_trt_used      = 0 ;                                             
    943                                                                                                              
    944         m_cpt_trt_unused                = 0 ;                                                 
    945                                                                                    
    946         m_cpt_cleanup_fsm_ivt_lock      = 0 ;                                             
    947         m_cpt_cleanup_fsm_n_ivt_lock    = 0 ;                                                         
    948                                                                                      
    949         m_cpt_multi_ack_fsm_ivt_lock    = 0 ;                                                 
    950         m_cpt_multi_ack_fsm_n_ivt_lock  = 0 ;                                             
    951                                                                                    
    952         m_cpt_ivt_unused                = 0 ;                             
    953                                                                                      
    954         m_cpt_read_fsm_heap_lock        = 0 ;                                                     
    955         m_cpt_write_fsm_heap_lock       = 0 ;                                                 
    956         m_cpt_cas_fsm_heap_lock         = 0 ;                                             
    957         m_cpt_cleanup_fsm_heap_lock     = 0 ;                                                         
    958         m_cpt_xram_rsp_fsm_heap_lock    = 0 ;                                                             
    959         m_cpt_multi_ack_fsm_heap_lock   = 0 ;                                                 
    960                                                                                    
    961         m_cpt_read_fsm_n_heap_lock      = 0 ;                                                 
    962         m_cpt_write_fsm_n_heap_lock     = 0 ;                                             
    963         m_cpt_cas_fsm_n_heap_lock       = 0 ;                                                     
    964         m_cpt_cleanup_fsm_n_heap_lock   = 0 ;                                                     
    965         m_cpt_xram_rsp_fsm_n_heap_lock  = 0 ;                                                         
    966         m_cpt_multi_ack_fsm_n_heap_lock = 0 ;                                                         
    967                                                                                                                  
    968         m_cpt_read_fsm_heap_used        = 0 ;                                                 
    969         m_cpt_write_fsm_heap_used       = 0 ;                                                 
    970         m_cpt_cas_fsm_heap_used         = 0 ;                                             
    971         m_cpt_cleanup_fsm_heap_used     = 0 ;                                         
    972         m_cpt_xram_rsp_fsm_heap_used    = 0 ;                                         
    973         m_cpt_multi_ack_fsm_heap_used   = 0 ;                                                     
    974                                                                                      
    975         m_cpt_heap_unused               = 0 ;                     
    976         m_cpt_slot_inval                = 0 ;
    977    
     829        m_cpt_reset_count               = m_cpt_cycles;
     830
     831        m_cpt_read_local                = 0;
     832        m_cpt_read_remote               = 0;
     833        m_cpt_read_cost                 = 0;
     834
     835        m_cpt_write_local               = 0;
     836        m_cpt_write_remote              = 0;
     837        m_cpt_write_flits_local         = 0;
     838        m_cpt_write_flits_remote        = 0;
     839        m_cpt_write_cost                = 0;
     840
     841        m_cpt_ll_local                  = 0;
     842        m_cpt_ll_remote                 = 0;
     843        m_cpt_ll_cost                   = 0;
     844
     845        m_cpt_sc_local                  = 0;
     846        m_cpt_sc_remote                 = 0;
     847        m_cpt_sc_cost                   = 0;
     848
     849        m_cpt_cas_local                 = 0;
     850        m_cpt_cas_remote                = 0;
     851        m_cpt_cas_cost                  = 0;
     852
     853        m_cpt_minval                    = 0;
     854        m_cpt_minval_local              = 0;
     855        m_cpt_minval_remote             = 0;
     856        m_cpt_minval_cost               = 0;
     857
     858        m_cpt_binval                    = 0;
     859        m_cpt_write_broadcast           = 0;
     860        m_cpt_getm_broadcast            = 0;
     861
     862        m_cpt_cleanup_local             = 0;
     863        m_cpt_cleanup_remote            = 0;
     864        m_cpt_cleanup_cost              = 0;
     865        m_cpt_cleanup_data_local        = 0;
     866        m_cpt_cleanup_data_remote       = 0;
     867        m_cpt_cleanup_data_cost         = 0;
     868
     869        m_cpt_read_miss                 = 0;
     870        m_cpt_write_miss                = 0;
     871        m_cpt_write_dirty               = 0;
     872        m_cpt_getm_miss                 = 0;
     873
     874        m_cpt_getm_local                = 0;
     875        m_cpt_getm_remote               = 0;
     876        m_cpt_getm_cost                 = 0;
     877
     878        m_cpt_inval_ro_local            = 0;
     879        m_cpt_inval_ro_remote           = 0;
     880        m_cpt_inval_ro_cost             = 0;
     881
     882        m_cpt_trt_rb                    = 0;
     883        m_cpt_trt_full                  = 0;
     884        m_cpt_put                       = 0;
     885        m_cpt_get                       = 0;
     886
     887        m_cpt_heap_unused               = 0;
     888        m_cpt_slot_inval                = 0;
    978889    }
    979890
    980891
    981892    /////////////////////////////////////////
    982     tmpl(void)::print_stats(bool activity_counters = true, bool stats = true)
     893    tmpl(void)::print_stats(bool activity_counters)
    983894    {
    984895        std::cout << "**********************************" << std::dec << std::endl;
     
    993904                << "[001] NUMBER OF CYCLES          = " << m_cpt_cycles << std::endl
    994905                << std::endl
    995                 << "[002] LOCAL READ                = " << m_cpt_read_miss_local << std::endl
    996                 << "[003] REMOTE READ               = " << m_cpt_read_miss_remote << std::endl
    997                 << "[004] READ COST (FLITS * DIST)  = " << m_cpt_read_miss_cost << std::endl
     906                << "[010] LOCAL READ                = " << m_cpt_read_local << std::endl
     907                << "[011] REMOTE READ               = " << m_cpt_read_remote << std::endl
     908                << "[012] READ COST (FLITS * DIST)  = " << m_cpt_read_cost << std::endl
    998909                << std::endl
    999                 << "[005] LOCAL WRITE               = " << m_cpt_write_local << std::endl
    1000                 << "[006] REMOTE WRITE              = " << m_cpt_write_remote << std::endl
    1001                 << "[007] WRITE FLITS LOCAL         = " << m_cpt_write_flits_local << std::endl
    1002                 << "[008] WRITE FLITS REMOTE        = " << m_cpt_write_flits_remote << std::endl
    1003                 << "[009] WRITE COST (FLITS * DIST) = " << m_cpt_write_cost << std::endl
     910                << "[020] LOCAL WRITE               = " << m_cpt_write_local << std::endl
     911                << "[021] REMOTE WRITE              = " << m_cpt_write_remote << std::endl
     912                << "[022] WRITE FLITS LOCAL         = " << m_cpt_write_flits_local << std::endl
     913                << "[023] WRITE FLITS REMOTE        = " << m_cpt_write_flits_remote << std::endl
     914                << "[024] WRITE COST (FLITS * DIST) = " << m_cpt_write_cost << std::endl
     915                << "[025] WRITE L1 MISS NCC         = " << "0" << std::endl
    1004916                << std::endl
    1005                 << "[010] LOCAL LL                  = " << m_cpt_ll_local << std::endl
    1006                 << "[011] REMOTE LL                 = " << m_cpt_ll_remote << std::endl
    1007                 << "[012] LL COST (FLITS * DIST)    = " << m_cpt_ll_cost << std::endl
     917                << "[030] LOCAL LL                  = " << m_cpt_ll_local << std::endl
     918                << "[031] REMOTE LL                 = " << m_cpt_ll_remote << std::endl
     919                << "[032] LL COST (FLITS * DIST)    = " << m_cpt_ll_cost << std::endl
    1008920                << std::endl
    1009                 << "[013] LOCAL SC                  = " << m_cpt_sc_local << std::endl
    1010                 << "[014] REMOTE SC                 = " << m_cpt_sc_remote << std::endl
    1011                 << "[015] SC COST (FLITS * DIST)    = " << m_cpt_sc_cost << std::endl
     921                << "[040] LOCAL SC                  = " << m_cpt_sc_local << std::endl
     922                << "[041] REMOTE SC                 = " << m_cpt_sc_remote << std::endl
     923                << "[042] SC COST (FLITS * DIST)    = " << m_cpt_sc_cost << std::endl
    1012924                << std::endl
    1013                 << "[016] LOCAL CAS                 = " << m_cpt_cas_local << std::endl
    1014                 << "[017] REMOTE CAS                = " << m_cpt_cas_remote << std::endl
    1015                 << "[018] CAS COST (FLITS * DIST)   = " << m_cpt_cas_cost << std::endl
     925                << "[050] LOCAL CAS                 = " << m_cpt_cas_local << std::endl
     926                << "[051] REMOTE CAS                = " << m_cpt_cas_remote << std::endl
     927                << "[052] CAS COST (FLITS * DIST)   = " << m_cpt_cas_cost << std::endl
    1016928                << std::endl
    1017                 << "[019] REQUESTS TRIG. UPDATE     = " << m_cpt_update << std::endl
    1018                 << "[020] LOCAL UPDATE              = " << m_cpt_update_local << std::endl
    1019                 << "[021] REMOTE UPDATE             = " << m_cpt_update_remote << std::endl
    1020                 << "[022] UPDT COST (FLITS * DIST)  = " << m_cpt_update_cost << std::endl
     929                << "[060] REQUESTS TRIG. UPDATE     = " << "0" << std::endl
     930                << "[061] LOCAL UPDATE              = " << "0" << std::endl
     931                << "[062] REMOTE UPDATE             = " << "0" << std::endl
     932                << "[063] UPDT COST (FLITS * DIST)  = " << "0" << std::endl
    1021933                << std::endl
    1022                 << "[023] REQUESTS TRIG. M_INV      = " << m_cpt_minval << std::endl
    1023                 << "[024] LOCAL M_INV               = " << m_cpt_minval_local << std::endl
    1024                 << "[025] REMOTE M_INV              = " << m_cpt_minval_remote << std::endl
    1025                 << "[026] M_INV COST (FLITS * DIST) = " << m_cpt_minval_cost << std::endl
     934                << "[070] REQUESTS TRIG. M_INV      = " << m_cpt_minval << std::endl
     935                << "[071] LOCAL M_INV               = " << m_cpt_minval_local << std::endl
     936                << "[072] REMOTE M_INV              = " << m_cpt_minval_remote << std::endl
     937                << "[073] M_INV COST (FLITS * DIST) = " << m_cpt_minval_cost << std::endl
    1026938                << std::endl
    1027                 << "[027] BROADCAT INVAL            = " << m_cpt_binval << std::endl
     939                << "[080] BROADCAT INVAL            = " << m_cpt_binval << std::endl
     940                << "[081] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     941                << "[082] GETM BROADCAST            = " << m_cpt_getm_broadcast << std::endl
    1028942                << std::endl
    1029                 << "[028] LOCAL CLEANUP             = " << m_cpt_cleanup_local << std::endl
    1030                 << "[029] REMOTE CLEANUP            = " << m_cpt_cleanup_remote << std::endl
    1031                 << "[030] CLNUP COST (FLITS * DIST) = " << m_cpt_cleanup_cost << std::endl
     943                << "[090] LOCAL CLEANUP             = " << m_cpt_cleanup_local << std::endl
     944                << "[091] REMOTE CLEANUP            = " << m_cpt_cleanup_remote << std::endl
     945                << "[092] CLNUP COST (FLITS * DIST) = " << m_cpt_cleanup_cost << std::endl
     946                << "[093] LOCAL CLEANUP DATA        = " << m_cpt_cleanup_data_local << std::endl
     947                << "[094] REMOTE CLEANUP DATA       = " << m_cpt_cleanup_data_remote << std::endl
     948                << "[095] CLEANUP DATA COST         = " << m_cpt_cleanup_data_cost << std::endl
    1032949                << std::endl
     950                << "[100] READ MISS                 = " << m_cpt_read_miss << std::endl
     951                << "[101] WRITE MISS                = " << m_cpt_write_miss << std::endl
     952                << "[102] WRITE DIRTY               = " << m_cpt_write_dirty << std::endl
     953                << "[103] GETM MISS                 = " << m_cpt_getm_miss << std::endl
    1033954                << std::endl
    1034                 << "[031] READ MISS                 = " << m_cpt_read_miss << std::endl
    1035                 << "[032] WRITE MISS                = " << m_cpt_write_miss << std::endl
    1036                 << "[033] WRITE DIRTY               = " << m_cpt_write_dirty << std::endl
    1037                 << "[034] RD BLOCKED BY HIT IN TRT  = " << m_cpt_trt_rb << std::endl
    1038                 << "[035] TRANS BLOCKED BY FULL TRT = " << m_cpt_trt_full << std::endl
    1039                 << "[036] PUT (UNIMPLEMENTED)       = " << m_cpt_put << std::endl
    1040                 << "[037] GET (UNIMPLEMENTED)       = " << m_cpt_get << std::endl
    1041                 << "[038] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     955                << "[110] RD BLOCKED BY HIT IN TRT  = " << m_cpt_trt_rb << std::endl
     956                << "[111] TRANS BLOCKED BY FULL TRT = " << m_cpt_trt_full << std::endl
     957                << "[120] PUT (UNIMPLEMENTED)       = " << m_cpt_put << std::endl
     958                << "[121] GET (UNIMPLEMENTED)       = " << m_cpt_get << std::endl
     959                << "[130] MIN HEAP SLOT AVAILABLE   = " << "-1" << std::endl
    1042960                << std::endl
    1043 
     961                << "[140] NCC TO CC (READ)          = " << "0" << std::endl
     962                << "[141] NCC TO CC (WRITE)         = " << "0" << std::endl
     963                << std::endl
     964                << "[150] LOCAL GETM                = " << m_cpt_getm_local << std::endl
     965                << "[151] REMOTE GETM               = " << m_cpt_getm_remote << std::endl
     966                << "[152] GETM COST (FLITS * DIST)  = " << m_cpt_getm_cost << std::endl
     967                << std::endl
     968                << "[160] LOCAL INVAL RO            = " << m_cpt_inval_ro_local << std::endl
     969                << "[161] REMOTE INVAL RO           = " << m_cpt_inval_ro_remote << std::endl
     970                << "[162] INVAL RO COST             = " << m_cpt_inval_ro_cost << std::endl
     971                << std::endl;
     972
     973#if 0
    1044974                << "[050] LOCAL GETM MISS           = " << m_cpt_getm_miss_local << std::endl
    1045975                << "[051] REMOTE GETM MISS          = " << m_cpt_getm_miss_remote << std::endl
     
    1047977                << "[053] REMOTE GETM HIT           = " << m_cpt_getm_hit_remote << std::endl
    1048978                << "[054] GETM COST (FLITS * DIST)  = " << m_cpt_getm_cost << std::endl
    1049                 << std::endl
    1050                 << "[055] CLEANUP WITH DATA         = " << m_cpt_cleanup_with_data << std::endl
    1051979                << std::endl
    1052980                << "[056] MULTI_ACK_MISS            = " << m_cpt_multi_ack_miss << std::endl
     
    1064992                << "[066] EVICTED SLOT              = " << m_cpt_slot_inval << std::endl
    1065993                << std::endl;
     994#endif
    1066995        }
    1067996
    1068         if (stats) {
    1069             std::cout << "----------------------------------" << std::dec << std::endl;
    1070             std::cout << "---      Calculated Stats      ---" << std::dec << std::endl;
    1071             std::cout << "----------------------------------" << std::dec << std::endl;
    1072             std::cout
    1073                 << "[100] READ TOTAL            = " << m_cpt_read_miss_local + m_cpt_read_miss_remote << std::endl
    1074                 << "[101] READ RATE             = " << (double) (m_cpt_read_miss_local + m_cpt_read_miss_remote) / m_cpt_cycles << std::endl
    1075                 << "[102] LOCAL READ RATE       = " << (double) m_cpt_read_miss_local / m_cpt_cycles << std::endl
    1076                 << "[103] REMOTE READ RATE      = " << (double) m_cpt_read_miss_remote / m_cpt_cycles << std::endl
    1077                 << "[104] READ MISS RATE        = " << (double) m_cpt_read_miss / (m_cpt_read_miss_local + m_cpt_read_miss_remote) << std::endl
    1078                 << "[105] GETM MISS TOTAL       = " << m_cpt_getm_miss_local + m_cpt_getm_miss_remote << std::endl
    1079                 << "[106] GETM MISS RATE        = " << (double) (m_cpt_getm_miss_local + m_cpt_getm_miss_remote) / m_cpt_cycles << std::endl
    1080                 << "[107] LOCAL GETM MISS RATE  = " << (double) m_cpt_getm_miss_local / m_cpt_cycles << std::endl
    1081                 << "[108] REMOTE GETM MISS RATE = " << (double) m_cpt_getm_miss_remote / m_cpt_cycles << std::endl
    1082                 << "[109] GETM HIT TOTAL        = " << m_cpt_getm_hit_local + m_cpt_getm_hit_remote << std::endl
    1083                 << "[110] GETM HIT RATE         = " << (double) (m_cpt_getm_hit_local + m_cpt_getm_hit_remote) / m_cpt_cycles << std::endl
    1084                 << "[111] LOCAL GETM HIT RATE   = " << (double) m_cpt_getm_hit_local / m_cpt_cycles << std::endl
    1085                 << "[112] REMOTE GETM HIT RATE  = " << (double) m_cpt_getm_hit_remote / m_cpt_cycles << std::endl
    1086 
    1087                 << "[113] GETM TOTAL            = " << m_cpt_getm_hit_local + m_cpt_getm_hit_remote + m_cpt_getm_miss_remote + m_cpt_getm_miss_local << std::endl
    1088 
    1089                 << "[114] GETM MISS RATE        = " << (double) m_cpt_read_miss / (m_cpt_getm_hit_local + m_cpt_getm_hit_remote + m_cpt_getm_miss_remote + m_cpt_getm_miss_local) << std::endl
    1090  
    1091                 << std::endl
    1092                 << "[115] WRITE TOTAL           = " << m_cpt_write_local + m_cpt_write_remote << std::endl
    1093                 << "[116] WRITE RATE            = " << (double) (m_cpt_write_local + m_cpt_write_remote) / m_cpt_cycles << std::endl
    1094                 << "[117] LOCAL WRITE RATE      = " << (double) m_cpt_write_local / m_cpt_cycles << std::endl
    1095                 << "[118] REMOTE WRITE RATE     = " << (double) m_cpt_write_remote / m_cpt_cycles << std::endl
    1096                 << "[119] WRITE MISS RATE       = " << (double) m_cpt_write_miss / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1097                 << "[120] WRITE BURST TOTAL     = " << m_cpt_write_flits_local + m_cpt_write_flits_remote << std::endl
    1098                 << "[121] WRITE BURST AVERAGE   = " << (double) (m_cpt_write_flits_local + m_cpt_write_flits_remote) / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1099                 << "[122] LOCAL WRITE BURST AV. = " << (double) m_cpt_write_flits_local / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1100                 << "[123] REMOTE WRITE BURST AV = " << (double) m_cpt_write_flits_remote / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    1101                 << std::endl
    1102                 << "[124] UPDATE RATE                = " << (double) m_cpt_update / m_cpt_cycles << std::endl
    1103                 << "[125] AV. UPDATE PER UP REQ      = " << (double) (m_cpt_update_local + m_cpt_update_remote) / m_cpt_update << std::endl
    1104                 << "[126] AV. LOC UPDT PER UP REQ    = " << (double) m_cpt_update_local / m_cpt_update << std::endl
    1105                 << "[127] AV. REMOTE UPDT PER UP REQ = " << (double) m_cpt_update_remote / m_cpt_update << std::endl
    1106                 << std::endl
    1107                 << "[128] INVAL MULTICAST RATE  = " << (double) m_cpt_minval / m_cpt_cycles << std::endl
    1108                 << "[129] AVE. INVAL PER M_INV  = " << (double) (m_cpt_minval_local + m_cpt_minval_remote) / m_cpt_minval << std::endl
    1109                 << "[130] AV. LOC INV PER M_INV = " << (double) m_cpt_minval_local / m_cpt_minval << std::endl
    1110                 << "[131] AV. REM INV PER M_INV = " << (double) m_cpt_minval_remote / m_cpt_minval << std::endl
    1111                 << std::endl
    1112                 << "[132] INVAL BROADCAST RATE  = " << (double) m_cpt_binval / m_cpt_cycles << std::endl
    1113                 << "[133] WRITE DIRTY RATE      = " << (double) m_cpt_write_dirty / m_cpt_cycles << std::endl
    1114                 << std::endl
    1115                 << "[134] CLEANUP RATE          = " << (double) (m_cpt_cleanup_local + m_cpt_cleanup_remote) / m_cpt_cycles << std::endl
    1116                 << "[135] LOCAL CLEANUP RATE    = " << (double) m_cpt_cleanup_local / m_cpt_cycles << std::endl
    1117                 << "[136] REMOTE CLEANUP RATE   = " << (double) m_cpt_cleanup_remote / m_cpt_cycles << std::endl
    1118                 << "[137] LL RATE               = " << (double) (m_cpt_ll_local + m_cpt_ll_remote) / m_cpt_cycles << std::endl
    1119                 << "[138] LOCAL LL RATE         = " << (double) m_cpt_ll_local / m_cpt_cycles << std::endl
    1120                 << "[139] REMOTE LL RATE        = " << (double) m_cpt_ll_remote / m_cpt_cycles << std::endl
    1121                 << "[140] SC RATE               = " << (double) (m_cpt_sc_local + m_cpt_sc_remote) / m_cpt_cycles << std::endl
    1122                 << "[141] LOCAL SC RATE         = " << (double) m_cpt_sc_local / m_cpt_cycles << std::endl
    1123                 << "[142] REMOTE SC RATE        = " << (double) m_cpt_sc_remote / m_cpt_cycles << std::endl
    1124                 << "[143] CAS RATE              = " << (double) (m_cpt_cas_local + m_cpt_cas_remote) / m_cpt_cycles << std::endl
    1125                 << "[144] LOCAL CAS RATE        = " << (double) m_cpt_cas_local / m_cpt_cycles << std::endl
    1126                 << "[145] REMOTE CAS RATE       = " << (double) m_cpt_cas_remote / m_cpt_cycles << std::endl
    1127                 << "[124] MULTI ACK RATE        = " << (double) (m_cpt_multi_ack_hit + m_cpt_multi_ack_miss) / m_cpt_cycles << std::endl
    1128                 << std::endl;
    1129         }
     997        // No more calculated stats
    1130998    }
    1131999
    11321000
    11331001    /////////////////////////////////
    1134     tmpl(/**/) ::~VciMemCache()
    1135         /////////////////////////////////
     1002    tmpl(/**/)::~VciMemCache()
     1003    /////////////////////////////////
    11361004    {
    11371005        delete [] m_seg;
     
    11681036    //////////////////////////////////
    11691037    tmpl(void) ::transition()
    1170         //////////////////////////////////
     1038    //////////////////////////////////
    11711039    {
    11721040        using soclib::common::uint32_log2;
    11731041
    11741042        // RESET
    1175         if(! p_resetn.read())
     1043        if (! p_resetn.read())
    11761044        {
    11771045
     
    13171185
    13181186            // Activity counters
    1319             m_cpt_reset_count               = 0 ;                   
    1320             m_cpt_read_miss_local           = 0 ;
    1321             m_cpt_read_miss_remote          = 0 ;
    1322             m_cpt_read_miss_cost            = 0 ;     
    1323                                                                                      
    1324             m_cpt_getm_miss_local           = 0 ;     
    1325             m_cpt_getm_miss_remote          = 0 ;     
    1326                                                                                              
    1327             m_cpt_getm_hit_local            = 0 ;     
    1328             m_cpt_getm_hit_remote           = 0 ;         
    1329             m_cpt_getm_cost                 = 0 ;
    1330                                                                                                  
    1331             m_cpt_write_local               = 0 ;     
    1332             m_cpt_write_remote              = 0 ;     
    1333             m_cpt_write_flits_local         = 0 ;         
    1334             m_cpt_write_flits_remote        = 0 ;         
    1335             m_cpt_write_cost                = 0 ;   
    1336 
    1337             m_cpt_ll_local                  = 0 ;         
    1338             m_cpt_ll_remote                 = 0 ;             
    1339             m_cpt_ll_cost                   = 0 ;         
    1340                                                                                                
    1341             m_cpt_sc_local                  = 0 ;                             
    1342             m_cpt_sc_remote                 = 0 ;                             
    1343             m_cpt_sc_cost                   = 0 ;                             
    1344                                                                                              
    1345             m_cpt_cas_local                 = 0 ;                                 
    1346             m_cpt_cas_remote                = 0 ;                                     
    1347             m_cpt_cas_cost                  = 0 ;                                 
    1348                                                                                          
    1349             m_cpt_update                    = 0 ;                     
    1350             m_cpt_update_local              = 0 ;                             
    1351             m_cpt_update_remote             = 0 ;                             
    1352             m_cpt_update_cost               = 0 ;                         
    1353                                                                                        
    1354             m_cpt_minval                    = 0 ;                 
    1355             m_cpt_minval_local              = 0 ;                         
    1356             m_cpt_minval_remote             = 0 ;                     
    1357             m_cpt_minval_cost               = 0 ;                         
    1358                                                                                          
    1359             m_cpt_binval                    = 0 ;                     
    1360                                                                                                  
    1361             m_cpt_cleanup_local             = 0 ;                             
    1362             m_cpt_cleanup_remote            = 0 ;                         
    1363             m_cpt_cleanup_with_data         = 0 ;                             
    1364             m_cpt_cleanup_cost              = 0 ;                         
    1365                                                                                          
    1366             m_cpt_multi_ack_miss            = 0 ;                         
    1367             m_cpt_multi_ack_hit             = 0 ;                     
    1368             m_cpt_multi_ack_hit_with_data   = 0 ;                             
    1369                                                                                          
    1370                                                      
    1371             m_cpt_read_miss                 = 0 ;                                     
    1372             m_cpt_getm_miss                 = 0 ;                                 
    1373             m_cpt_getm_broadcast            = 0 ;                                     
    1374             m_cpt_getm_minval               = 0 ;                                     
    1375             m_cpt_write_miss                = 0 ;                                             
    1376             m_cpt_write_dirty               = 0 ;                                             
    1377             m_cpt_write_broadcast           = 0 ;                                                 
    1378             m_cpt_write_minval              = 0 ;                                         
    1379             m_cpt_cas_broadcast             = 0 ;                                                 
    1380             m_cpt_cas_minval                = 0 ;                                                                 
    1381             m_cpt_cas_miss                  = 0 ;                                                 
    1382                                                                                          
    1383             m_cpt_read_locked_rb            = 0 ;                                                                 
    1384             m_cpt_cas_locked_rb             = 0 ;                                                                 
    1385             m_cpt_write_locked_rb           = 0 ;                                                                                             
    1386                                                                                          
    1387             m_cpt_trt_rb                    = 0 ;                                                                 
    1388             m_cpt_trt_full                  = 0 ;                                                             
    1389             m_cpt_put                       = 0 ;                                                             
    1390             m_cpt_get                       = 0 ;                                                             
    1391                                                                                              
    1392             m_cpt_read_fsm_dir_lock         = 0 ;                                                                         
    1393             m_cpt_read_fsm_n_dir_lock       = 0 ;                                                                         
    1394             m_cpt_write_fsm_dir_lock        = 0 ;                                                                 
    1395             m_cpt_write_fsm_n_dir_lock      = 0 ;                                                                                         
    1396             m_cpt_xram_rsp_fsm_dir_lock     = 0 ;                                                                             
    1397             m_cpt_xram_rsp_fsm_n_dir_lock   = 0 ;                                                                 
    1398             m_cpt_cas_fsm_dir_lock          = 0 ;                                                         
    1399             m_cpt_cas_fsm_n_dir_lock        = 0 ;                                             
    1400             m_cpt_cleanup_fsm_dir_lock      = 0 ;                                                         
    1401             m_cpt_cleanup_fsm_n_dir_lock    = 0 ;                                                     
    1402             m_cpt_multi_ack_fsm_dir_lock    = 0 ;                                                 
    1403             m_cpt_multi_ack_fsm_n_dir_lock  = 0 ;                                                     
    1404                                                                                            
    1405             m_cpt_dir_unused                = 0 ;                                                             
    1406             m_cpt_read_fsm_dir_used         = 0 ;                                                             
    1407             m_cpt_write_fsm_dir_used        = 0 ;                                                     
    1408             m_cpt_cas_fsm_dir_used          = 0 ;                                             
    1409             m_cpt_xram_rsp_fsm_dir_used     = 0 ;                                                 
    1410             m_cpt_cleanup_fsm_dir_used      = 0 ;                                                 
    1411             m_cpt_multi_ack_fsm_dir_used    = 0 ;                                                         
    1412                                                                                                                        
    1413             m_cpt_read_fsm_trt_lock         = 0 ;                                                 
    1414             m_cpt_write_fsm_trt_lock        = 0 ;                                                         
    1415             m_cpt_cas_fsm_trt_lock          = 0 ;                                                         
    1416             m_cpt_xram_rsp_fsm_trt_lock     = 0 ;                                                     
    1417             m_cpt_ixr_fsm_trt_lock          = 0 ;                                                     
    1418                                                                                          
    1419             m_cpt_read_fsm_n_trt_lock       = 0 ;                                             
    1420             m_cpt_write_fsm_n_trt_lock      = 0 ;                                                         
    1421             m_cpt_cas_fsm_n_trt_lock        = 0 ;                                                     
    1422             m_cpt_xram_rsp_fsm_n_trt_lock   = 0 ;                                         
    1423             m_cpt_ixr_cmd_fsm_n_trt_lock    = 0 ;                                                             
    1424             m_cpt_ixr_rsp_fsm_n_trt_lock    = 0 ;                                                     
    1425                                                                                          
    1426             m_cpt_read_fsm_trt_used         = 0 ;                                                     
    1427             m_cpt_write_fsm_trt_used        = 0 ;                                                         
    1428             m_cpt_cas_fsm_trt_used          = 0 ;                                             
    1429             m_cpt_xram_rsp_fsm_trt_used     = 0 ;                                                     
    1430             m_cpt_ixr_cmd_fsm_trt_used      = 0 ;                                                 
    1431             m_cpt_ixr_rsp_fsm_trt_used      = 0 ;                                                     
    1432             m_cpt_cleanup_fsm_trt_used      = 0 ;                                             
    1433                                                                                                                  
    1434             m_cpt_trt_unused                = 0 ;                                                 
    1435                                                                                        
    1436             m_cpt_cleanup_fsm_ivt_lock      = 0 ;                                             
    1437             m_cpt_cleanup_fsm_n_ivt_lock    = 0 ;                                                         
    1438                                                                                          
    1439             m_cpt_multi_ack_fsm_ivt_lock    = 0 ;                                                 
    1440             m_cpt_multi_ack_fsm_n_ivt_lock  = 0 ;                                             
    1441                                                                                        
    1442             m_cpt_ivt_unused                = 0 ;                             
    1443                                                                                          
    1444             m_cpt_read_fsm_heap_lock        = 0 ;                                                     
    1445             m_cpt_write_fsm_heap_lock       = 0 ;                                                 
    1446             m_cpt_cas_fsm_heap_lock         = 0 ;                                             
    1447             m_cpt_cleanup_fsm_heap_lock     = 0 ;                                                         
    1448             m_cpt_xram_rsp_fsm_heap_lock    = 0 ;                                                             
    1449             m_cpt_multi_ack_fsm_heap_lock   = 0 ;                                                 
    1450                                                                                        
    1451             m_cpt_read_fsm_n_heap_lock      = 0 ;                                                 
    1452             m_cpt_write_fsm_n_heap_lock     = 0 ;                                             
    1453             m_cpt_cas_fsm_n_heap_lock       = 0 ;                                                     
    1454             m_cpt_cleanup_fsm_n_heap_lock   = 0 ;                                                     
    1455             m_cpt_xram_rsp_fsm_n_heap_lock  = 0 ;                                                         
    1456             m_cpt_multi_ack_fsm_n_heap_lock = 0 ;                                                         
    1457                                                                                                                      
    1458             m_cpt_read_fsm_heap_used        = 0 ;                                                 
    1459             m_cpt_write_fsm_heap_used       = 0 ;                                                 
    1460             m_cpt_cas_fsm_heap_used         = 0 ;                                             
    1461             m_cpt_cleanup_fsm_heap_used     = 0 ;                                         
    1462             m_cpt_xram_rsp_fsm_heap_used    = 0 ;                                         
    1463             m_cpt_multi_ack_fsm_heap_used   = 0 ;                                                     
    1464                                                                                          
    1465             m_cpt_heap_unused               = 0 ;                     
    1466             m_cpt_slot_inval                = 0 ;
     1187            m_cpt_reset_count               = 0;
     1188            m_cpt_read_local                = 0;
     1189            m_cpt_read_remote               = 0;
     1190            m_cpt_read_cost                 = 0;
     1191
     1192            m_cpt_write_local               = 0;
     1193            m_cpt_write_remote              = 0;
     1194            m_cpt_write_flits_local         = 0;
     1195            m_cpt_write_flits_remote        = 0;
     1196            m_cpt_write_cost                = 0;
     1197
     1198            m_cpt_ll_local                  = 0;
     1199            m_cpt_ll_remote                 = 0;
     1200            m_cpt_ll_cost                   = 0;
     1201
     1202            m_cpt_sc_local                  = 0;
     1203            m_cpt_sc_remote                 = 0;
     1204            m_cpt_sc_cost                   = 0;
     1205
     1206            m_cpt_cas_local                 = 0;
     1207            m_cpt_cas_remote                = 0;
     1208            m_cpt_cas_cost                  = 0;
     1209
     1210            m_cpt_minval                    = 0;
     1211            m_cpt_minval_local              = 0;
     1212            m_cpt_minval_remote             = 0;
     1213            m_cpt_minval_cost               = 0;
     1214
     1215            m_cpt_binval                    = 0;
     1216            m_cpt_write_broadcast           = 0;
     1217            m_cpt_getm_broadcast            = 0;
     1218
     1219            m_cpt_cleanup_local             = 0;
     1220            m_cpt_cleanup_remote            = 0;
     1221            m_cpt_cleanup_cost              = 0;
     1222            m_cpt_cleanup_data_local        = 0;
     1223            m_cpt_cleanup_data_remote       = 0;
     1224            m_cpt_cleanup_data_cost         = 0;
     1225
     1226            m_cpt_read_miss                 = 0;
     1227            m_cpt_write_miss                = 0;
     1228            m_cpt_write_dirty               = 0;
     1229            m_cpt_getm_miss                 = 0;
     1230
     1231            m_cpt_getm_local                = 0;
     1232            m_cpt_getm_remote               = 0;
     1233            m_cpt_getm_cost                 = 0;
     1234
     1235            m_cpt_inval_ro_local            = 0;
     1236            m_cpt_inval_ro_remote           = 0;
     1237            m_cpt_inval_ro_cost             = 0;
     1238
     1239            m_cpt_trt_rb                    = 0;
     1240            m_cpt_trt_full                  = 0;
     1241            m_cpt_put                       = 0;
     1242            m_cpt_get                       = 0;
     1243
     1244            m_cpt_heap_unused               = 0;
     1245            m_cpt_slot_inval                = 0;
     1246
    14671247            return;
    14681248        }
     
    15151295
    15161296#if DEBUG_MEMC_GLOBAL
    1517         if(m_debug)
     1297        if (m_debug)
    15181298        {
    15191299            std::cout
     
    15651345            //////////////////
    15661346            case TGT_CMD_IDLE:     // waiting a VCI command (RAM or CONFIG)
    1567                 if(p_vci_tgt.cmdval)
     1347                if (p_vci_tgt.cmdval)
    15681348                {
    15691349
    15701350#if DEBUG_MEMC_TGT_CMD
    1571                     if(m_debug)
     1351                    if (m_debug)
    15721352                        std::cout << "  <MEMC " << name()
    15731353                            << " TGT_CMD_IDLE> Receive command from srcid "
     
    15871367                        {
    15881368                            found = true;
    1589                             if ( m_seg[seg_id]->special() ) config = true;
     1369                            if (m_seg[seg_id]->special() ) config = true;
    15901370                        }
    15911371                    }
     
    15931373                    if (!found)                /////////// out of segment error
    15941374                    {
    1595                         r_tgt_cmd_fsm   = TGT_CMD_ERROR;
    1596                     }
    1597                     else if ( config )              /////////// configuration command
     1375                        r_tgt_cmd_fsm = TGT_CMD_ERROR;
     1376                    }
     1377                    else if (config )              /////////// configuration command
    15981378                    {
    15991379                        if (!p_vci_tgt.eop.read()) r_tgt_cmd_fsm = TGT_CMD_ERROR;
    1600                         else                            r_tgt_cmd_fsm = TGT_CMD_CONFIG;
     1380                        else                       r_tgt_cmd_fsm = TGT_CMD_CONFIG;
    16011381                    }
    16021382                    else                            //////////// memory access
    16031383                    {
    1604                         if ( p_vci_tgt.cmd.read() == vci_param_int::CMD_READ )
     1384                        if (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)
    16051385                        {
    16061386                            // check that the pktid is either :
     
    16151395                            r_tgt_cmd_fsm = TGT_CMD_READ;
    16161396                        }
    1617                         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
     1397                        else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
    16181398                        {
    16191399                          // check that the pktid is TYPE_WRITE
     
    16221402                            r_tgt_cmd_fsm = TGT_CMD_WRITE;
    16231403                        }
    1624                         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
     1404                        else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
    16251405                        {
    16261406                            // check that the pktid is TYPE_LL
     
    16311411                            r_tgt_cmd_fsm = TGT_CMD_READ;
    16321412                        }
    1633                         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP)
     1413                        else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP)
    16341414                        {
    16351415                            // check that the pktid is either :
     
    16421422                                    "The type specified in the pktid field is incompatible with the NOP CMD");
    16431423
    1644                             if((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
    1645                             else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE;
     1424                            if ((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
     1425                            else                                            r_tgt_cmd_fsm = TGT_CMD_WRITE;
    16461426                        }
    16471427                        else
     
    16571437
    16581438                // wait if pending request
    1659                 if(r_tgt_cmd_to_tgt_rsp_req.read()) break;
     1439                if (r_tgt_cmd_to_tgt_rsp_req.read()) break;
    16601440
    16611441                // consume all the command packet flits before sending response error
    1662                 if ( p_vci_tgt.cmdval and p_vci_tgt.eop )
     1442                if (p_vci_tgt.cmdval and p_vci_tgt.eop)
    16631443                {
    16641444                    r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
     
    16701450
    16711451#if DEBUG_MEMC_TGT_CMD
    1672                     if(m_debug)
     1452                    if (m_debug)
    16731453                        std::cout << "  <MEMC " << name()
    16741454                            << " TGT_CMD_ERROR> Segmentation violation:"
     
    18851665                    uint32_t wdata = p_vci_tgt.wdata.read();     
    18861666
    1887                     if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
     1667                    if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
    18881668                            and (cell == MEMC_LOCK) )
    18891669                    {
     
    18931673                        r_config_lock    = true;
    18941674                    }
    1895                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)  // release lock
     1675                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)  // release lock
    18961676                            and (cell == MEMC_LOCK))
    18971677                    {
     
    19001680                        r_config_lock    = false;
    19011681                    }
    1902                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_lo
     1682                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_lo
    19031683                            and (cell == MEMC_ADDR_LO))
    19041684                    {
     
    19111691                            ((addr_t)wdata);
    19121692                    }
    1913                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_hi
     1693                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_hi
    19141694                            and (cell == MEMC_ADDR_HI))
    19151695                    {
     
    19191699                            (((addr_t) wdata) << 32);
    19201700                    }
    1921                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
     1701                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
    19221702                            and (cell == MEMC_BUF_LENGTH))
    19231703                    {
     
    19291709                        r_config_rsp_lines  = 0;
    19301710                    }
    1931                     else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set cmd type
     1711                    else if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set cmd type
    19321712                            and (cell == MEMC_CMD_TYPE))
    19331713                    {
     
    19451725                    }
    19461726
    1947                     if ( need_rsp )
     1727                    if (need_rsp )
    19481728                    {
    19491729                        // blocked if previous pending request to TGT_RSP FSM
    1950                         if ( r_tgt_cmd_to_tgt_rsp_req.read() ) break;
     1730                        if (r_tgt_cmd_to_tgt_rsp_req.read() ) break;
    19511731
    19521732                        r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
     
    19641744
    19651745#if DEBUG_MEMC_TGT_CMD
    1966                     if(m_debug)
     1746                    if (m_debug)
    19671747                        std::cout << "  <MEMC " << name() << " TGT_CMD_CONFIG> Configuration request:"
    19681748                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    19781758
    19791759                // check that the read does not cross a cache line limit.
    1980                 if ( ((m_x[(addr_t) p_vci_tgt.address.read()]+ (p_vci_tgt.plen.read() >>2)) > 16) and
     1760                if (((m_x[(addr_t) p_vci_tgt.address.read()]+ (p_vci_tgt.plen.read() >>2)) > 16) and
    19811761                        (p_vci_tgt.cmd.read() != vci_param_int::CMD_LOCKED_READ))
    19821762                {
     
    19861766                }
    19871767                // check single flit
    1988                 if(!p_vci_tgt.eop.read())
     1768                if (!p_vci_tgt.eop.read())
    19891769                {
    19901770                    std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
     
    19931773                }
    19941774                // check plen for LL
    1995                 if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
     1775                if ((p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
    19961776                        (p_vci_tgt.plen.read() != 8) )
    19971777                {
     
    20011781                }
    20021782
    2003                 if ( p_vci_tgt.cmdval and m_cmd_read_addr_fifo.wok() )
     1783                if (p_vci_tgt.cmdval and m_cmd_read_addr_fifo.wok() )
    20041784                {
    20051785
    20061786#if DEBUG_MEMC_TGT_CMD
    2007                     if(m_debug)
     1787                    if (m_debug)
    20081788                        std::cout << "  <MEMC " << name() << " TGT_CMD_READ> Push into read_fifo:"
    20091789                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    20161796                    // <Activity counters>
    20171797                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) {
    2018                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_ll_local++;
    2019                         else                                      m_cpt_ll_remote++;
    2020                         m_cpt_ll_cost += req_distance(p_vci_tgt.srcid.read()); // LL on a single word
    2021                     }
    2022                     else {
    2023                         if ((p_vci_tgt.pktid.read() & 0x7) == TYPE_WRITE)
    2024                         {
    2025                             if ((p_vci_tgt.pktid.read() & 0x8) == 0x8)
    2026                             {
    2027                                 if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_getm_hit_local++;
    2028                                 else                                      m_cpt_getm_hit_remote++;
    2029                             }
    2030                             else
    2031                             {
    2032                                 if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_getm_miss_local++;
    2033                                 else                                      m_cpt_getm_miss_remote++;
    2034                             }
    2035                             m_cpt_getm_cost += req_distance(p_vci_tgt.srcid.read());
     1798                        if (is_local_req(p_vci_tgt.srcid.read()))
     1799                        {
     1800                            m_cpt_ll_local++;
    20361801                        }
    20371802                        else
    20381803                        {
    2039                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_read_miss_local++;
    2040                             else                                      m_cpt_read_miss_remote++;
    2041                             m_cpt_read_miss_cost += req_distance(p_vci_tgt.srcid.read());
    2042                         }
     1804                            m_cpt_ll_remote++;
     1805                        }
     1806                        // (1 (CMD) + 2 (RSP)) VCI flits for LL => 2 + 3 dspin flits
     1807                        m_cpt_ll_cost += 5 * req_distance(p_vci_tgt.srcid.read()); // LL on a single word
     1808                    }
     1809                    else if ((p_vci_tgt.pktid.read() & 0x7) == TYPE_WRITE)
     1810                    {
     1811                        if (is_local_req(p_vci_tgt.srcid.read()))
     1812                        {
     1813                            m_cpt_getm_local++;
     1814                        }
     1815                        else
     1816                        {
     1817                            m_cpt_getm_remote++;
     1818                        }
     1819                        // (1 (CMD) + m_words (RSP)) flits VCI => 2 + m_words + 1 flits dspin
     1820                        m_cpt_getm_cost += (3 + m_words) * req_distance(p_vci_tgt.srcid.read());
     1821                    }
     1822                    else
     1823                    {
     1824                        if (is_local_req(p_vci_tgt.srcid.read()))
     1825                        {
     1826                            m_cpt_read_local++;
     1827                        }
     1828                        else
     1829                        {
     1830                            m_cpt_read_remote++;
     1831                        }
     1832                        // (1 (CMD) + m_words (RSP)) flits VCI => 2 + m_words + 1 flits dspin
     1833                        m_cpt_read_cost += (3 + m_words) * req_distance(p_vci_tgt.srcid.read());
    20431834                    }
    20441835                    // </Activity counters>
     
    20491840                ///////////////////
    20501841            case TGT_CMD_WRITE:
    2051                 if(p_vci_tgt.cmdval and m_cmd_write_addr_fifo.wok())
    2052                 {
    2053 
     1842                if (p_vci_tgt.cmdval and m_cmd_write_addr_fifo.wok())
     1843                {
     1844                    uint32_t plen = p_vci_tgt.plen.read();
    20541845#if DEBUG_MEMC_TGT_CMD
    2055                     if(m_debug)
     1846                    if (m_debug)
    20561847                        std::cout << "  <MEMC " << name() << " TGT_CMD_WRITE> Push into write_fifo:"
    20571848                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    20611852                            << " / wdata = " << p_vci_tgt.wdata.read()
    20621853                            << " / be = " << p_vci_tgt.be.read()
    2063                             << " / plen = " << std::dec << p_vci_tgt.plen.read() << std::endl;
     1854                            << " / plen = " << std::dec << plen << std::endl;
    20641855#endif
    20651856                    cmd_write_fifo_put = true;
    20661857                    // <Activity counters>
    20671858                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
    2068                         m_cpt_sc_cost += req_distance(p_vci_tgt.srcid.read());
     1859                        // (2 (CMD) + 1 (RSP)) flits VCI => 4 + (1 (success) || 2 (failure)) flits dspin
     1860                        m_cpt_sc_cost += 5 * req_distance(p_vci_tgt.srcid.read());
    20691861                    }
    20701862                    else {
    2071                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_flits_local++;
    2072                         else                                      m_cpt_write_flits_remote++;
    2073                         m_cpt_write_cost += req_distance(p_vci_tgt.srcid.read());
     1863                        if (is_local_req(p_vci_tgt.srcid.read()))
     1864                        {
     1865                            m_cpt_write_flits_local++;
     1866                        }
     1867                        else
     1868                        {
     1869                            m_cpt_write_flits_remote++;
     1870                        }
     1871                        // (burst_size (CMD) + 1 (RSP) flits VCI => 2 + burst_size + 1 flits dspin
     1872                        m_cpt_write_cost += (3 + (plen >> 2)) * req_distance(p_vci_tgt.srcid.read());
    20741873                    }
    20751874                    // </Activity counters>
     
    20781877                        // <Activity counters>
    20791878                        if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
    2080                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_sc_local++;
    2081                             else                                      m_cpt_sc_remote++;
    2082 
     1879                            if (is_local_req(p_vci_tgt.srcid.read()))
     1880                            {
     1881                                m_cpt_sc_local++;
     1882                            }
     1883                            else
     1884                            {
     1885                                m_cpt_sc_remote++;
     1886                            }
    20831887                        }
    20841888                        else {
    2085                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_local++;
    2086                             else                                      m_cpt_write_remote++;
     1889                            if (is_local_req(p_vci_tgt.srcid.read()))
     1890                            {
     1891                                m_cpt_write_local++;
     1892                            }
     1893                            else
     1894                            {
     1895                                m_cpt_write_remote++;
     1896                            }
    20871897                        }
    20881898                        // </Activity counters>
     
    20931903                /////////////////
    20941904            case TGT_CMD_CAS:
    2095                 if((p_vci_tgt.plen.read() != 8) and (p_vci_tgt.plen.read() != 16))
     1905                if ((p_vci_tgt.plen.read() != 8) and (p_vci_tgt.plen.read() != 16))
    20961906                {
    20971907                    std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_CAS state"
     
    21001910                }
    21011911
    2102                 if(p_vci_tgt.cmdval and m_cmd_cas_addr_fifo.wok())
     1912                if (p_vci_tgt.cmdval and m_cmd_cas_addr_fifo.wok())
    21031913                {
    21041914
    21051915#if DEBUG_MEMC_TGT_CMD
    2106                     if(m_debug)
     1916                    if (m_debug)
    21071917                        std::cout << "  <MEMC " << name() << " TGT_CMD_CAS> Pushing command into cmd_cas_fifo:"
    21081918                            << " address = " << std::hex << p_vci_tgt.address.read()
     
    21171927                    if (p_vci_tgt.eop) {
    21181928                        // <Activity counters>
    2119                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_cas_local++;
    2120                         else                                      m_cpt_cas_remote++;
    2121                         m_cpt_cas_cost += req_distance(p_vci_tgt.srcid.read());
     1929                        if (is_local_req(p_vci_tgt.srcid.read()))
     1930                        {
     1931                            m_cpt_cas_local++;
     1932                        }
     1933                        else
     1934                        {
     1935                            m_cpt_cas_remote++;
     1936                        }
     1937                        // (2 (CMD) + 1 (RSP)) flits VCI => 4 + (1 (success) || 2 (failure)) flits dspin
     1938                        m_cpt_cas_cost += 5 * req_distance(p_vci_tgt.srcid.read());
    21221939                        // </Activity counters>
    21231940                        r_tgt_cmd_fsm = TGT_CMD_IDLE;
     
    21511968                    uint64_t flit = m_cc_receive_to_multi_ack_fifo.read();
    21521969
    2153                     if( not multi_ack_fifo_rok )
     1970                    if (not multi_ack_fifo_rok)
    21541971                        break;
    21551972
    2156                     size_t ivt_index    = DspinDhccpParam::dspin_get(flit,
    2157                                     DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
    2158 
    2159                     bool miss_updt    = DspinDhccpParam::dspin_get(flit,
    2160                                     DspinDhccpParam::MULTI_ACK_UPDT_MISS);
    2161 
    2162                     bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     1973                    size_t ivt_index = DspinHmesiParam::dspin_get(flit,
     1974                                    DspinHmesiParam::MULTI_ACK_UPDT_INDEX);
     1975
     1976                    bool miss_updt = DspinHmesiParam::dspin_get(flit,
     1977                                    DspinHmesiParam::MULTI_ACK_UPDT_MISS);
     1978
     1979                    bool eop = DspinHmesiParam::dspin_get(flit, DspinHmesiParam::P2M_EOP) == 0x1;
    21631980
    21641981                    cc_receive_to_multi_ack_fifo_get = true;
     
    21711988                    r_multi_ack_miss_updt = miss_updt;
    21721989
    2173                     if(miss_updt)
    2174                         m_cpt_multi_ack_miss ++;
    2175                     else
    2176                         m_cpt_multi_ack_hit ++;
    2177 
    2178                     if( not eop)
    2179                     {
    2180                         r_multi_ack_fsm = MULTI_ACK_GET_DATA;
     1990                    if (not eop)
     1991                    {
    21811992                        r_multi_ack_need_data = true;
    21821993                        r_multi_ack_data_index = 0;
    2183                         m_cpt_multi_ack_hit_with_data ++;
     1994                        r_multi_ack_fsm = MULTI_ACK_GET_DATA;
    21841995                    }
    21851996                    else
    21861997                    {
     1998                        r_multi_ack_need_data = false;
    21871999                        r_multi_ack_fsm = MULTI_ACK_DIR_REQ;
    2188                         r_multi_ack_need_data = false;
    21892000                    }
    21902001
    21912002#if DEBUG_MEMC_MULTI_ACK
    2192                     if(m_debug)
     2003                    if (m_debug)
    21932004                    {
    21942005                        if (multi_ack_fifo_rok)
     
    22112022
    22122023                        uint32_t data =
    2213                             DspinDhccpParam::dspin_get (flit, DspinDhccpParam::CLEANUP_DATA_UPDT);
    2214 
    2215                         bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     2024                            DspinHmesiParam::dspin_get (flit, DspinHmesiParam::CLEANUP_DATA_UPDT);
     2025
     2026                        bool eop = DspinHmesiParam::dspin_get(flit, DspinHmesiParam::P2M_EOP) == 0x1;
    22162027#if DEBUG_MEMC_CLEANUP
    2217                         if(m_debug)
     2028                        if (m_debug)
    22182029                        {
    22192030                            std::cout
     
    22422053            case MULTI_ACK_IVT_LOCK:
    22432054                {
    2244                     m_cpt_multi_ack_fsm_ivt_lock ++;
    2245                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK)  break;
    2246 
    2247                     m_cpt_multi_ack_fsm_n_ivt_lock ++;
     2055                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK)  break;
    22482056
    22492057                    assert( r_alloc_dir_fsm.read() == ALLOC_DIR_MULTI_ACK && " BAD ALLOC_DIR_MULTI_ACK IN MULTI_ACK_IVT_LOCK STATE");
    2250                     size_t index  = r_multi_ack_ivt_index.read();
    2251                     size_t count  = m_ivt.count(index);
    2252                     size_t nline  = m_ivt.nline(index);
     2058                    size_t index = r_multi_ack_ivt_index.read();
     2059                    size_t count = m_ivt.count(index);
     2060                    size_t nline = m_ivt.nline(index);
    22532061                    r_multi_ack_nline = nline;
    22542062                    r_multi_ack_srcid = m_ivt.srcid(index);
     
    22562064                    r_multi_ack_pktid = m_ivt.pktid(index);
    22572065                    r_multi_ack_rsp   = m_ivt.need_rsp(index);
    2258                     //bool is_valid = m_ivt.is_valid(index);
    2259 
    2260                     // if(r_multi_ack_miss_updt.read())
    2261                     //{
    2262                         r_multi_ack_fsm = MULTI_ACK_DIR_LOCK; // this way may be bring about the problem of critical path
    2263                     //}                   
    2264                     //else
    2265                     //{
    2266                         bool is_updt  = m_ivt.is_update(index);
     2066                    uint32_t srcid = m_ivt.srcid(index);
    22672067                   
    2268                         assert(is_updt && "MULTI_ACK: is not an updt index for a multi ack rsp");
    2269                         assert(count == 1 && "there is only one copy in the memc");
    2270 
    2271                     //  r_multi_ack_fsm = MULTI_ACK_IVT_CLEAR;
     2068                    // <Activity Counters>
     2069                    // We count "read-only invalidations" at the same place as
     2070                    // multi ack.
     2071                    // The idea is that a RO inval is always responded by a multi ack,
     2072                    // and that a multi ack is sent only for inval RO.
     2073                    // Thus, we add one to the cost for the inval RO fleet, and
     2074                    // depending on the response, we add either 1 or m_words + 1 for the cost for the multi ack flits
     2075                    if (r_multi_ack_need_data.read())
     2076                    {
     2077                        // multi_ack with data
     2078                        if (is_local_req(srcid))
     2079                        {
     2080                            m_cpt_inval_ro_local++;
     2081                        }
     2082                        else
     2083                        {
     2084                            m_cpt_inval_ro_remote++;
     2085                        }
     2086                        // 2 flits for inval RO + (m_words + 1) flits for the multi ack
     2087                        m_cpt_inval_ro_cost += (m_words + 1) * req_distance(srcid);
     2088                    }
     2089                    else
     2090                    {
     2091                        // multi_ack without data
     2092                        if (is_local_req(srcid))
     2093                        {
     2094                            m_cpt_inval_ro_local++;
     2095                        }
     2096                        else
     2097                        {
     2098                            m_cpt_inval_ro_remote++;
     2099                        }
     2100                        // 2 flits for inval RO + 1 flit for the multi ack
     2101                        m_cpt_inval_ro_cost += 3 * req_distance(srcid); // 1 flit
     2102                    }
     2103                    // </Activity Counters>
     2104
     2105
     2106                    r_multi_ack_fsm = MULTI_ACK_DIR_LOCK; // this way may be bring about the problem of critical path
     2107                    bool is_updt  = m_ivt.is_update(index);
     2108                   
     2109                    assert(is_updt && "MULTI_ACK: is not an updt index for a multi ack rsp");
     2110                    assert(count == 1 && "there is only one copy in the memc");
    22722111
    22732112#if DEBUG_MEMC_MULTI_ACK
    2274                     if(m_debug)
     2113                    if (m_debug)
    22752114                        std::cout << "  <MEMC " << name()
    22762115                            << " MULTI_ACK_IVT_LOCK> "
     
    22832122            case MULTI_ACK_IVT_CLEAR:
    22842123                {
    2285                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK )
     2124                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK )
    22862125                    {
    22872126                        std::cout
     
    22972136           
    22982137#if DEBUG_MEMC_MULTI_ACK
    2299                     if(m_debug)
     2138                    if (m_debug)
    23002139                        std::cout << "  <MEMC " << name()
    23012140                            << " MULTI_ACK_IVT_CLEAR> IVT clear:"
     
    23082147            case MULTI_ACK_DIR_REQ:   // Get the lock to the directory
    23092148                {
    2310                     m_cpt_multi_ack_fsm_dir_lock ++;
    2311                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK) break;
     2149                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK) break;
    23122150
    23132151                    r_multi_ack_fsm = MULTI_ACK_IVT_LOCK;
    23142152                    //std::cout << " MEM_CACHE : CLEANUP_DIR_REQ" << std::endl;
    2315                     m_cpt_multi_ack_fsm_n_dir_lock ++;
    23162153
    23172154#if DEBUG_MEMC_CLEANUP
    2318                     if(m_debug)
     2155                    if (m_debug)
    23192156                        std::cout << "  <MEMC " << name() << " MULTI_ACK_DIR_REQ> Requesting DIR lock" << std::endl;
    23202157#endif
     
    23252162            case MULTI_ACK_DIR_LOCK: //updt data with the registers which have saved the set and way
    23262163                {
    2327                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
     2164                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
    23282165                    {
    23292166                        std::cout
     
    23492186
    23502187#if DEBUG_MEMC_MULTI_ACK
    2351                     if(m_debug)
     2188                    if (m_debug)
    23522189                    {
    23532190                        std::cout
     
    23652202                    }
    23662203#endif
    2367                     assert( (entry.state == ENTRY_LOCKED) && "mutli rsp check the entry, the line is not locked!!!");
     2204                    assert((entry.state == ENTRY_LOCKED) && "multi rsp check the entry, the line is not locked!!!");
    23682205                       
    2369                     if(r_multi_ack_miss_updt.read() and entry.count) //cache L1 has sent the cleanup when it receives the cc_updt request,
     2206                    if (r_multi_ack_miss_updt.read() and entry.count) //cache L1 has sent the cleanup when it receives the cc_updt request,
    23702207                    {
    23712208                        r_multi_ack_fsm = MULTI_ACK_IVT_CHANGE;
    23722209                    }
    2373                     else if( not entry.count or match_ll) // The line has been already evicted from cache L1
     2210                    else if (not entry.count or match_ll) // The line has been already evicted from cache L1
    23742211                    {
    23752212                        assert(((entry.count == 1) or (entry.count == 0)) && "multi ack for a ll request, count is 1");
    2376                         r_multi_ack_fsm        = MULTI_ACK_DIR_UPDT;
     2213                        r_multi_ack_fsm = MULTI_ACK_DIR_UPDT;
    23772214                    }
    23782215                    else
    23792216                    {
    2380                         r_multi_ack_fsm        = MULTI_ACK_HEAP_REQ;
     2217                        r_multi_ack_fsm = MULTI_ACK_HEAP_REQ;
    23812218                    }
    23822219                    break;
    23832220                }
    23842221                /////////////
    2385             case MULTI_ACK_IVT_CHANGE:   // release all locks and retry from beginning
     2222            case MULTI_ACK_IVT_CHANGE:
    23862223                {                 
    2387                     if(r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK )
     2224                    if (r_alloc_ivt_fsm.read() != ALLOC_IVT_MULTI_ACK)
    23882225                    {
    23892226                        std::cout
     
    23962233                    m_ivt.change(r_multi_ack_ivt_index.read());
    23972234#if DEBUG_MEMC_MULTI_ACK
    2398                     if(m_debug)
     2235                    if (m_debug)
    23992236                    {
    24002237                        std::cout << "  <MEMC " << name()
     
    24082245            case MULTI_ACK_DIR_UPDT:
    24092246                {
    2410                     if(r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
     2247                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_MULTI_ACK)
    24112248                    {
    24122249                        std::cout
     
    24202257                    bool match_ll = ((r_multi_ack_pktid.read() & 0x07) == TYPE_LL);
    24212258
    2422                     if(r_multi_ack_need_data.read())
    2423                     {
    2424                         for(size_t word=0; word<m_words ; word++)
     2259                    if (r_multi_ack_need_data.read())
     2260                    {
     2261                        for (size_t word = 0; word<m_words; word++)
    24252262                        {
    24262263                            m_cache_data.write(r_multi_ack_way.read(),
     
    24292266                                               r_multi_ack_data[word]);
    24302267                        }
    2431                        // addr_t min = r_multi_ack_nline.read()*m_words*4 ;
    2432                        // addr_t max = r_multi_ack_nline.read()*m_words*4 + (m_words - 1)*4;
    2433                        // m_llsc_table.sw(min, max);
    2434  
    24352268                    }
    24362269                    else
    24372270                    {
    2438                         m_cache_data.read_line( r_multi_ack_way.read(),
    2439                                                 r_multi_ack_set.read(),
    2440                                                 r_multi_ack_data);
     2271                        m_cache_data.read_line(r_multi_ack_way.read(),
     2272                                               r_multi_ack_set.read(),
     2273                                               r_multi_ack_data);
    24412274                    }
    24422275
    24432276                    DirectoryEntry entry;
    2444                     entry.is_cnt         = false;
    2445                     entry.dirty          = r_multi_ack_dirty.read() or r_multi_ack_need_data.read();
    2446                     entry.tag            = r_multi_ack_tag.read();
    2447                     entry.lock           = r_multi_ack_lock.read();
    2448                     entry.ptr            = 0;
    2449 
    2450                     if(match_ll)
    2451                     {
    2452                         entry.owner.srcid    = r_multi_ack_copy.read();
    2453                         entry.count          = r_multi_ack_count.read();
     2277                    entry.is_cnt = false;
     2278                    entry.dirty  = r_multi_ack_dirty.read() or r_multi_ack_need_data.read();
     2279                    entry.tag    = r_multi_ack_tag.read();
     2280                    entry.lock   = r_multi_ack_lock.read();
     2281                    entry.ptr    = 0;
     2282
     2283                    if (match_ll)
     2284                    {
     2285                        entry.owner.srcid = r_multi_ack_copy.read();
     2286                        entry.count       = r_multi_ack_count.read();
    24542287                    }
    24552288                    else
    24562289                    {
    2457                         entry.owner.srcid    = r_multi_ack_srcid.read();
    2458                         entry.count          = 1;
    2459                     }
    2460 
    2461 
    2462                    // if( (r_multi_ack_pktid.read() & 0x07) == 0x03 or match_ll)
    2463                    // {
    2464                         entry.state          = ENTRY_SHARED; // MISS INST
    2465                    // }
    2466                    //  else
    2467                    //  {
    2468                    //     entry.state          = ENTRY_EXCLUSIVE; // MISS DATA
    2469                    // }
    2470 
    2471                     if((r_multi_ack_pktid.read() & 0x7) == 0x03)
     2290                        entry.owner.srcid = r_multi_ack_srcid.read();
     2291                        entry.count       = 1;
     2292                    }
     2293
     2294                    entry.state = ENTRY_SHARED; // MISS INST
     2295
     2296                    if ((r_multi_ack_pktid.read() & 0x7) == 0x03)
    24722297                    {
    24732298                        entry.owner.inst = true;
     
    24832308                    r_multi_ack_fsm      = MULTI_ACK_IVT_CLEAR;
    24842309#if DEBUG_MEMC_MULTI_ACK
    2485                     if(m_debug)
     2310                    if (m_debug)
    24862311                    {
    24872312                        std::cout << "  <MEMC " << name() << " MULTI_ACK_DIR_UPDT>"
     
    24992324                // wait if pending request to the TGT_RSP FSM
    25002325                {
    2501                     if(r_multi_ack_to_tgt_rsp_req.read()) break;
    2502 
    2503                     for(size_t i = 0; i<m_words; i++)
     2326                    if (r_multi_ack_to_tgt_rsp_req.read()) break;
     2327
     2328                    for (size_t i = 0; i<m_words; i++)
    25042329                    {
    25052330                        r_multi_ack_to_tgt_rsp_data[i] = r_multi_ack_data[i].read();
    25062331                    }
    25072332                    // no pending request
    2508                     r_multi_ack_to_tgt_rsp_req     = true;
    2509                     if( r_read_to_multi_ack_req.read() and (r_read_to_multi_ack_nline.read() == r_multi_ack_nline.read()))
    2510                     {
    2511                         r_multi_ack_to_tgt_rsp_word    = r_read_to_multi_ack_first_word.read();
    2512                         r_multi_ack_to_tgt_rsp_length  = r_read_to_multi_ack_length.read();
    2513                         r_read_to_multi_ack_req        = false;
     2333                    r_multi_ack_to_tgt_rsp_req = true;
     2334                    if (r_read_to_multi_ack_req.read() and (r_read_to_multi_ack_nline.read() == r_multi_ack_nline.read()))
     2335                    {
     2336                        r_multi_ack_to_tgt_rsp_word   = r_read_to_multi_ack_first_word.read();
     2337                        r_multi_ack_to_tgt_rsp_length = r_read_to_multi_ack_length.read();
     2338                        r_read_to_multi_ack_req       = false;
    25142339                    }
    25152340                    else
    25162341                    {
    2517                         r_multi_ack_to_tgt_rsp_word    = 0;
    2518                         r_multi_ack_to_tgt_rsp_length  = 16;
    2519                     }
    2520 
    2521                     r_multi_ack_to_tgt_ll_key      = r_read_to_multi_ack_ll_key.read();
    2522                     r_multi_ack_to_tgt_rsp_srcid   = r_multi_ack_srcid.read();
    2523                     r_multi_ack_to_tgt_rsp_trdid   = r_multi_ack_trdid.read();
    2524 
    2525                    // if(r_multi_ack_rsp_shared.read()) // rsp read with shared or exclusive state
    2526                    // {
    2527                         r_multi_ack_to_tgt_rsp_pktid = r_multi_ack_pktid.read();
    2528                    // }
    2529                    // else
    2530                    //{
    2531                    //    r_multi_ack_to_tgt_rsp_pktid = 0x08 + r_multi_ack_pktid.read(); 
    2532                    //}
    2533 
    2534                    r_multi_ack_fsm = MULTI_ACK_IDLE;
     2342                        r_multi_ack_to_tgt_rsp_word   = 0;
     2343                        r_multi_ack_to_tgt_rsp_length = 16;
     2344                    }
     2345
     2346                    r_multi_ack_to_tgt_ll_key    = r_read_to_multi_ack_ll_key.read();
     2347                    r_multi_ack_to_tgt_rsp_srcid = r_multi_ack_srcid.read();
     2348                    r_multi_ack_to_tgt_rsp_trdid = r_multi_ack_trdid.read();
     2349                    r_multi_ack_to_tgt_rsp_pktid = r_multi_ack_pktid.read();
     2350
     2351                    r_multi_ack_fsm = MULTI_ACK_IDLE;
    25352352
    25362353#if DEBUG_MEMC_MULTI_ACK
    2537                     if(m_debug)
     2354                    if (m_debug)
    25382355                        std::cout << "  <MEMC " << name() << " MULTI_ACK_RSP>"
    25392356                            << " Send a response to a previous read/ll request: "
     
    25532370            case MULTI_ACK_HEAP_REQ:    // Get the lock to the HEAP directory
    25542371                {
    2555                     m_cpt_multi_ack_fsm_n_heap_lock ++;
    2556                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK)
     2372                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK)
    25572373                    {
    25582374                        r_multi_ack_fsm = MULTI_ACK_HEAP_LOCK;
    25592375                    }
    25602376
    2561                     m_cpt_multi_ack_fsm_heap_lock ++;
    25622377#if DEBUG_MEMC_MULTI_ACK
    2563                     if(m_debug)
     2378                    if (m_debug)
    25642379                        std::cout << "  <MEMC " << name() << " MULTI_ACK_HEAP_REQ>"
    25652380                            << " Requesting HEAP lock " << std::endl;
     
    25712386                // and prepare the HEAP update
    25722387                {
    2573                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
     2388                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
    25742389                       r_alloc_dir_fsm.read() == ALLOC_DIR_MULTI_ACK)
    25752390                    {
    2576                         if(r_multi_ack_need_data.read())
    2577                         {
    2578                             for(size_t word=0; word<m_words ; word++)
     2391                        if (r_multi_ack_need_data.read())
     2392                        {
     2393                            for (size_t word = 0; word < m_words ; word++)
    25792394                            {
    25802395                                m_cache_data.write(r_multi_ack_way.read(),
     
    25832398                                                   r_multi_ack_data[word]);
    25842399                            }
    2585 
    2586                            // addr_t min = r_multi_ack_nline.read()*m_words*4 ;
    2587                            // addr_t max = r_multi_ack_nline.read()*m_words*4 + (m_words - 1)*4;
    2588                            // m_llsc_table.sw(min, max);
    2589  
    25902400                        }
    25912401                        else
    25922402                        {
    2593                             m_cache_data.read_line( r_multi_ack_way.read(),
    2594                                                     r_multi_ack_set.read(),
    2595                                                     r_multi_ack_data);
     2403                            m_cache_data.read_line(r_multi_ack_way.read(),
     2404                                                   r_multi_ack_set.read(),
     2405                                                   r_multi_ack_data);
    25962406                        }
    25972407
     
    26062416                        entry.dirty  = r_multi_ack_dirty.read() or r_multi_ack_need_data.read();
    26072417                        entry.tag    = r_multi_ack_tag.read();
    2608                         if(not go_cnt)         // Not entering counter mode
    2609                         {
    2610                             entry.owner.srcid      = r_multi_ack_copy.read();
    2611                             entry.owner.inst       = r_multi_ack_copy_inst.read();
    2612                             entry.ptr              = m_heap.next_free_ptr();   // set pointer on the heap
    2613 
    2614                             HeapEntry heap_entry   = m_heap.next_free_entry();
    2615 
    2616                             r_multi_ack_next_ptr   = heap_entry.next;
    2617                             r_multi_ack_last_free  = (heap_entry.next == m_heap.next_free_ptr());
    2618                             r_multi_ack_fsm        = MULTI_ACK_HEAP_WRITE; // add an entry in the HEAP
     2418                        if (not go_cnt)         // Not entering counter mode
     2419                        {
     2420                            entry.owner.srcid = r_multi_ack_copy.read();
     2421                            entry.owner.inst  = r_multi_ack_copy_inst.read();
     2422                            entry.ptr         = m_heap.next_free_ptr();   // set pointer on the heap
     2423
     2424                            HeapEntry heap_entry = m_heap.next_free_entry();
     2425
     2426                            r_multi_ack_next_ptr  = heap_entry.next;
     2427                            r_multi_ack_last_free = (heap_entry.next == m_heap.next_free_ptr());
     2428                            r_multi_ack_fsm       = MULTI_ACK_HEAP_WRITE; // add an entry in the HEAP
    26192429                        }
    26202430                        else                // Entering Counter mode
     
    26292439
    26302440#if DEBUG_MEMC_MULTI_ACK
    2631                         if(m_debug)
     2441                        if (m_debug)
    26322442                            std::cout << "  <MEMC " << name() << " MULTI_ACK_HEAP_LOCK> Update directory:"
    26332443                                << " tag = " << std::hex << entry.tag
     
    26502460            case MULTI_ACK_HEAP_WRITE:       // add an entry in the heap
    26512461                {
    2652                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
     2462                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK and
    26532463                       r_alloc_dir_fsm.read() == ALLOC_DIR_MULTI_ACK)
    26542464                    {
    26552465                        HeapEntry heap_entry;
    2656                         heap_entry.owner.srcid    = r_multi_ack_srcid.read();
    2657 
    2658                         if( (r_multi_ack_pktid.read() & 0x07) == 0x03)
    2659                         {
    2660                             heap_entry.owner.inst     = 1;
     2466                        heap_entry.owner.srcid = r_multi_ack_srcid.read();
     2467
     2468                        if ((r_multi_ack_pktid.read() & 0x07) == 0x03)
     2469                        {
     2470                            heap_entry.owner.inst = 1;
    26612471                        }
    26622472                        else
    26632473                        {
    2664                             heap_entry.owner.inst     = 0;
    2665                         }
    2666 
    2667                         heap_entry.next           = m_heap.next_free_ptr();
     2474                            heap_entry.owner.inst = 0;
     2475                        }
     2476
     2477                        heap_entry.next = m_heap.next_free_ptr();
    26682478                        m_heap.write_free_entry(heap_entry);
    26692479                        m_heap.write_free_ptr(r_multi_ack_next_ptr.read());
    2670                         if(r_multi_ack_last_free.read())  m_heap.set_full();
     2480                        if (r_multi_ack_last_free.read())  m_heap.set_full();
    26712481
    26722482                        r_multi_ack_fsm = MULTI_ACK_IVT_CLEAR;
    26732483
    26742484#if DEBUG_MEMC_MULTI_ACK
    2675                         if(m_debug)
     2485                        if (m_debug)
    26762486                            std::cout << "  <MEMC " << name() << " MULTI_ACK_HEAP_WRITE> Add an entry in the heap:"
    26772487                                << " owner_id = " << std::hex << heap_entry.owner.srcid
     
    27542564        ////////////////////////////////////////////////////////////////////////////////////
    27552565
    2756         switch( r_config_fsm.read() )
     2566        switch (r_config_fsm.read())
    27572567        {
    27582568            /////////////////
    27592569            case CONFIG_IDLE:  // waiting a config request
    27602570                {
    2761                     if ( r_config_cmd.read() != MEMC_CMD_NOP
    2762                     {
    2763                         r_config_fsm    = CONFIG_LOOP;
     2571                    if (r_config_cmd.read() != MEMC_CMD_NOP
     2572                    {
     2573                        r_config_fsm = CONFIG_LOOP;
    27642574
    27652575#if DEBUG_MEMC_CONFIG
    2766                         if(m_debug)
     2576                        if (m_debug)
    27672577                            std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received"
    27682578                                << " address = " << std::hex << r_config_address.read()
     
    27762586            case CONFIG_LOOP:   // test last line to be handled
    27772587                {
    2778                     if ( r_config_cmd_lines.read() == 0 )
     2588                    if (r_config_cmd_lines.read() == 0)
    27792589                    {
    27802590                        r_config_cmd = MEMC_CMD_NOP;
     
    27872597
    27882598#if DEBUG_MEMC_CONFIG
    2789                     if(m_debug)
     2599                    if (m_debug)
    27902600                        std::cout << "  <MEMC " << name() << " CONFIG_LOOP>"
    27912601                            << " address = " << std::hex << r_config_address.read()   
     
    27982608            case CONFIG_WAIT:   // wait completion (last response)
    27992609                {
    2800                     if ( r_config_rsp_lines.read() == 0 )  // last response received
     2610                    if (r_config_rsp_lines.read() == 0)  // last response received
    28012611                    {
    28022612                        r_config_fsm = CONFIG_RSP;
     
    28042614
    28052615#if DEBUG_MEMC_CONFIG
    2806                     if(m_debug)
     2616                    if (m_debug)
    28072617                        std::cout << "  <MEMC " << name() << " CONFIG_WAIT>"
    28082618                            << " / lines to do = " << std::dec << r_config_rsp_lines.read() << std::endl;
     
    28132623            case CONFIG_RSP:  // request TGT_RSP FSM to return response
    28142624                {
    2815                     if ( not r_config_to_tgt_rsp_req.read() )
    2816                     {
    2817                         r_config_to_tgt_rsp_srcid  = r_config_srcid.read();
    2818                         r_config_to_tgt_rsp_trdid  = r_config_trdid.read();
    2819                         r_config_to_tgt_rsp_pktid  = r_config_pktid.read();
    2820                         r_config_to_tgt_rsp_error  = false;
    2821                         r_config_to_tgt_rsp_req    = true;
    2822                         r_config_fsm               = CONFIG_IDLE;
     2625                    if (not r_config_to_tgt_rsp_req.read() )
     2626                    {
     2627                        r_config_to_tgt_rsp_srcid = r_config_srcid.read();
     2628                        r_config_to_tgt_rsp_trdid = r_config_trdid.read();
     2629                        r_config_to_tgt_rsp_pktid = r_config_pktid.read();
     2630                        r_config_to_tgt_rsp_error = false;
     2631                        r_config_to_tgt_rsp_req   = true;
     2632                        r_config_fsm              = CONFIG_IDLE;
    28232633
    28242634#if DEBUG_MEMC_CONFIG
    2825                         if(m_debug)
     2635                        if (m_debug)
    28262636                            std::cout << "  <MEMC " << name() << " CONFIG_RSP> Request TGT_RSP FSM to return response:"
    28272637                                << " error = " << r_config_to_tgt_rsp_error.read()
     
    28382648            case CONFIG_DIR_REQ:  // Request directory lock
    28392649                {
    2840                     if ( r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG )
     2650                    if (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG )
    28412651                    {
    28422652                        r_config_fsm = CONFIG_DIR_ACCESS;
     
    28442654
    28452655#if DEBUG_MEMC_CONFIG
    2846                     if(m_debug)
     2656                    if (m_debug)
    28472657                        std::cout << "  <MEMC " << name() << " CONFIG_DIR_REQ>"
    28482658                            << " Request DIR access" << std::endl;
     
    28712681                            (r_config_cmd.read() == MEMC_CMD_INVAL))
    28722682                    {
    2873                         r_config_fsm    = CONFIG_IVT_LOCK;
    2874                     }
    2875                     else if ( (entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE) and                       // hit & sync command
     2683                        r_config_fsm = CONFIG_IVT_LOCK;
     2684                    }
     2685                    else if ((entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE) and                       // hit & sync command
    28762686                            entry.dirty and (r_config_cmd.read() == MEMC_CMD_SYNC) )
    28772687                    {
    28782688                        r_config_fsm = CONFIG_TRT_LOCK;
    28792689                    }
    2880                     else if( entry.state == ENTRY_LOCKED)
     2690                    else if (entry.state == ENTRY_LOCKED)
    28812691                    {   // wait for unlock
    28822692                        r_config_fsm = CONFIG_WAIT;
     
    28912701
    28922702#if DEBUG_MEMC_CONFIG
    2893                     if(m_debug)
     2703                    if (m_debug)
    28942704                        std::cout << "  <MEMC " << name() << " CONFIG_DIR_ACCESS> Accessing directory: "
    28952705                            << " address = " << std::hex << r_config_address.read()
     
    29122722                            "MEMC ERROR in CONFIG_TRT_LOCK state: bad DIR allocation");
    29132723
    2914                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG )
     2724                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG)
    29152725                    {
    29162726                        size_t index = 0;
    2917                         bool   wok  = not m_trt.full(index);
    2918 
    2919                         if ( not wok )
     2727                        bool wok = not m_trt.full(index);
     2728
     2729                        if (not wok)
    29202730                        {
    29212731                            r_config_fsm = CONFIG_LOOP;
     
    29232733                        else
    29242734                        {
    2925                             size_t          way = r_config_dir_way.read();
    2926                             size_t          set = m_y[r_config_address.read()];
     2735                            size_t way = r_config_dir_way.read();
     2736                            size_t set = m_y[r_config_address.read()];
    29272737
    29282738                            // reset dirty bit in DIR
     
    29402750
    29412751                            r_config_trt_index = index;
    2942                             r_config_fsm       = CONFIG_TRT_SET;
     2752                            r_config_fsm = CONFIG_TRT_SET;
    29432753                        }
    29442754
    29452755#if DEBUG_MEMC_CONFIG
    2946                         if(m_debug)
     2756                        if (m_debug)
    29472757                            std::cout << "  <MEMC " << name() << " CONFIG_TRT_LOCK> Access TRT: "
    29482758                                << " wok = " << std::dec << wok
     
    29562766                // and post a PUT request in TRT
    29572767                {
    2958                     assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
     2768                    assert((r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
    29592769                            "MEMC ERROR in CONFIG_TRT_SET state: bad DIR allocation");
    29602770
    2961                     assert( (r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG) and
     2771                    assert((r_alloc_trt_fsm.read() == ALLOC_TRT_CONFIG) and
    29622772                            "MEMC ERROR in CONFIG_TRT_SET state: bad TRT allocation");
    29632773
    29642774                    // read data into cache
    2965                     size_t          way = r_config_dir_way.read();
    2966                     size_t          set = m_y[r_config_address.read()];
     2775                    size_t way = r_config_dir_way.read();
     2776                    size_t set = m_y[r_config_address.read()];
    29672777                    std::vector<data_t> data_vector;
    29682778                    data_vector.clear();
    2969                     for(size_t word=0; word<m_words; word++)
    2970                     {
    2971                         uint32_t data = m_cache_data.read( way, set, word );
    2972                         data_vector.push_back( data );
     2779                    for (size_t word = 0; word < m_words; word++)
     2780                    {
     2781                        uint32_t data = m_cache_data.read(way, set, word);
     2782                        data_vector.push_back(data);
    29732783                    }
    29742784
     
    29922802
    29932803#if DEBUG_MEMC_CONFIG
    2994                     if(m_debug)
     2804                    if (m_debug)
    29952805                        std::cout << "  <MEMC " << name() << " CONFIG_TRT_SET> PUT request in TRT:"
    29962806                            << " address = " << std::hex << r_config_address.read()
     
    30022812            case CONFIG_PUT_REQ:       // post PUT request to IXR_CMD_FSM
    30032813                {
    3004                     if ( not r_config_to_ixr_cmd_req.read() )
     2814                    if (not r_config_to_ixr_cmd_req.read())
    30052815                    {
    30062816                        r_config_to_ixr_cmd_req   = true;
     
    30082818
    30092819                        // prepare next iteration
    3010                         r_config_cmd_lines              = r_config_cmd_lines.read() - 1;
    3011                         r_config_address                = r_config_address.read() + (m_words<<2);
    3012                         r_config_fsm                    = CONFIG_LOOP;
     2820                        r_config_cmd_lines = r_config_cmd_lines.read() - 1;
     2821                        r_config_address   = r_config_address.read() + (m_words << 2);
     2822                        r_config_fsm       = CONFIG_LOOP;
    30132823
    30142824#if DEBUG_MEMC_CONFIG
    3015                         if(m_debug)
     2825                        if (m_debug)
    30162826                            std::cout << "  <MEMC " << name() << " CONFIG_PUT_REQ> post PUT request to IXR_CMD_FSM"
    30172827                                << " / address = " << std::hex << r_config_address.read() << std::endl;
     
    30272837                // directory if IVT not full.
    30282838                {
    3029                     assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
     2839                    assert((r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
    30302840                            "MEMC ERROR in CONFIG_IVT_LOCK state: bad DIR allocation");
    30312841
    3032                     if ( r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG )
     2842                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG)
    30332843                    {
    30342844                        size_t set        = m_y[(addr_t)(r_config_address.read())];
    30352845                        size_t way        = r_config_dir_way.read();
    30362846
    3037                         if ( r_config_dir_count.read() == 0 )     // inval DIR and return to LOOP
    3038                         {
    3039                             m_cache_directory.inval( way, set );
     2847                        if (r_config_dir_count.read() == 0)     // inval DIR and return to LOOP
     2848                        {
     2849                            m_cache_directory.inval(way, set);
    30402850                            r_config_cmd_lines  = r_config_cmd_lines.read() - 1;
    3041                             r_config_address    = r_config_address.read() + (m_words<<2);
     2851                            r_config_address    = r_config_address.read() + (m_words << 2);
    30422852                            r_config_fsm        = CONFIG_LOOP;
    30432853
    30442854#if DEBUG_MEMC_CONFIG
    3045                             if(m_debug)
     2855                            if (m_debug)
    30462856                                std::cout << "  <MEMC " << name() << " CONFIG_IVT_LOCK>"
    30472857                                    << " No copies in L1 : inval DIR entry"  << std::endl;
     
    30712881                                            index);
    30722882
    3073                             if ( wok )  // IVT success => inval DIR slot
     2883                            if (wok)  // IVT success => inval DIR slot
    30742884                            {
    3075                                 m_cache_directory.inval( way, set );
     2885                                m_cache_directory.inval(way, set);
    30762886                                r_config_ivt_index = index;
    30772887                                config_rsp_lines_incr = true;
    3078                                 if ( broadcast )  r_config_fsm = CONFIG_BC_SEND;
    3079                                 else              r_config_fsm = CONFIG_INVAL_SEND;
     2888                                if (broadcast)  r_config_fsm = CONFIG_BC_SEND;
     2889                                else             r_config_fsm = CONFIG_INVAL_SEND;
    30802890
    30812891#if DEBUG_MEMC_CONFIG
    3082                                 if(m_debug)
     2892                                if (m_debug)
    30832893                                    std::cout << "  <MEMC " << name() << " CONFIG_IVT_LOCK>"
    30842894                                        << " Inval DIR entry and register inval in IVT"
     
    30922902
    30932903#if DEBUG_MEMC_CONFIG
    3094                                 if(m_debug)
     2904                                if (m_debug)
    30952905                                    std::cout << "  <MEMC " << name() << " CONFIG_IVT_LOCK>"
    30962906                                        << " IVT full : release DIR & IVT locks and retry" << std::endl;
     
    31042914            case CONFIG_BC_SEND:    // Post a broadcast inval request to CC_SEND FSM
    31052915                {
    3106                     if( not r_config_to_cc_send_multi_req.read() and
    3107                             not r_config_to_cc_send_brdcast_req.read() )
     2916                    if (not r_config_to_cc_send_multi_req.read() and
     2917                            not r_config_to_cc_send_brdcast_req.read())
    31082918                    {
    31092919                        // post bc inval request
     
    31192929
    31202930#if DEBUG_MEMC_CONFIG
    3121                         if(m_debug)
     2931                        if (m_debug)
    31222932                            std::cout << "  <MEMC " << name() << " CONFIG_BC_SEND>"
    31232933                                << " Post a broadcast inval request to CC_SEND FSM"
     
    31302940            case CONFIG_INVAL_SEND:    // Post a multi inval request to CC_SEND FSM
    31312941                {
    3132                     if( not r_config_to_cc_send_multi_req.read() and
     2942                    if (not r_config_to_cc_send_multi_req.read() and
    31332943                            not r_config_to_cc_send_brdcast_req.read() )
    31342944                    {
     
    31432953                        config_to_cc_send_fifo_put      = true;
    31442954
    3145                         if ( r_config_dir_count.read() == 1 )  // one copy
     2955                        if (r_config_dir_count.read() == 1 )  // one copy
    31462956                        {
    31472957                            // prepare next iteration
     
    31562966
    31572967#if DEBUG_MEMC_CONFIG
    3158                         if(m_debug)
     2968                        if (m_debug)
    31592969                            std::cout << "  <MEMC " << name() << " CONFIG_INVAL_SEND>"
    31602970                                << " Post multi inval request to CC_SEND FSM"
     
    31692979            case CONFIG_HEAP_REQ:  // Try to get access to Heap
    31702980                {
    3171                     if ( r_alloc_heap_fsm.read() == ALLOC_HEAP_CONFIG )
    3172                     {
    3173                         r_config_fsm       = CONFIG_HEAP_SCAN;
     2981                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_CONFIG )
     2982                    {
     2983                        r_config_fsm = CONFIG_HEAP_SCAN;
    31742984                        r_config_heap_next = r_config_dir_ptr.read();
    31752985                    }
    31762986
    31772987#if DEBUG_MEMC_CONFIG
    3178                     if(m_debug)
     2988                    if (m_debug)
    31792989                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_REQ>"
    31802990                            << " Requesting HEAP lock" << std::endl;
     
    31933003                    config_to_cc_send_fifo_put   = true;
    31943004
    3195                     if ( m_config_to_cc_send_inst_fifo.wok() ) // inval request accepted
     3005                    if (m_config_to_cc_send_inst_fifo.wok()) // inval request accepted
    31963006                    {
    31973007                        r_config_heap_next = entry.next;
    3198                         if ( last_copy ) r_config_fsm = CONFIG_HEAP_LAST;
     3008                        if (last_copy) r_config_fsm = CONFIG_HEAP_LAST;
    31993009                    }
    32003010
    32013011#if DEBUG_MEMC_CONFIG
    3202                     if(m_debug)
     3012                    if (m_debug)
    32033013                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_SCAN>"
    32043014                            << " Post multi inval request to CC_SEND FSM"
     
    32173027                    last_entry.owner.inst  = false;
    32183028
    3219                     if ( m_heap.is_full() )
     3029                    if (m_heap.is_full())
    32203030                    {
    32213031                        last_entry.next = r_config_dir_ptr.read();
     
    32273037                    }
    32283038
    3229                     m_heap.write_free_ptr( r_config_dir_ptr.read() );
    3230                     m_heap.write( r_config_heap_next.read(), last_entry );
     3039                    m_heap.write_free_ptr(r_config_dir_ptr.read() );
     3040                    m_heap.write(r_config_heap_next.read(), last_entry );
    32313041
    32323042                    // prepare next iteration
    3233                     r_config_cmd_lines          = r_config_cmd_lines.read() - 1;
    3234                     r_config_address            = r_config_address.read() + (m_words<<2);
    3235                     r_config_fsm                = CONFIG_LOOP;
     3043                    r_config_cmd_lines = r_config_cmd_lines.read() - 1;
     3044                    r_config_address   = r_config_address.read() + (m_words<<2);
     3045                    r_config_fsm       = CONFIG_LOOP;
    32363046
    32373047#if DEBUG_MEMC_CONFIG
    3238                     if(m_debug)
     3048                    if (m_debug)
    32393049                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_LAST>"
    32403050                            << " Heap housekeeping" << std::endl;
     
    32723082            case READ_IDLE:  // waiting a read request
    32733083                {
    3274                     if(m_cmd_read_addr_fifo.rok())
     3084                    if (m_cmd_read_addr_fifo.rok())
    32753085                    {
    32763086
     
    32803090
    32813091#if DEBUG_MEMC_READ
    3282                         if(m_debug)
     3092                        if (m_debug)
    32833093                            std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
    32843094                                << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
     
    32983108            case READ_DIR_REQ:  // Get the lock to the directory
    32993109                {
    3300                     if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     3110                    if (r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    33013111                    {
    33023112                        r_read_fsm = READ_DIR_LOCK;
    3303                         m_cpt_read_fsm_n_dir_lock++;
    33043113                    }
    33053114
    33063115#if DEBUG_MEMC_READ
    3307                     if(m_debug)
     3116                    if (m_debug)
    33083117                        std::cout << "  <MEMC " << name() << " READ_DIR_REQ> Requesting DIR lock " << std::endl;
    33093118#endif
    3310 
    3311                     m_cpt_read_fsm_dir_lock++;
    3312 
    33133119                    break;
    33143120                }
     
    33233129                    DirectoryEntry entry =
    33243130                        m_cache_directory.read(m_cmd_read_addr_fifo.read(), way);
    3325                     if(((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) and not r_read_ll_done.read())   // access the global table ONLY when we have an LL cmd
    3326                     {
    3327                         r_read_ll_key   = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
     3131                    if (((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) and not r_read_ll_done.read())   // access the global table ONLY when we have an LL cmd
     3132                    {
     3133                        r_read_ll_key = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
    33283134                        /**//*std::cout << "MEMCACHE : from proc " << m_cmd_read_srcid_fifo.read()
    33293135                              << " | @ " << std::hex << m_cmd_read_addr_fifo.read()
     
    33313137                        r_read_ll_done  = true;
    33323138                    }
    3333 
    3334                     //bool s_getm_hit         = m_cmd_read_pktid_fifo.read() & 0x8;
    33353139
    33363140                    r_read_is_cnt           = entry.is_cnt;
     
    33503154                    bool cached_read = ((m_cmd_read_pktid_fifo.read() & 0x7) != 0) and ((m_cmd_read_pktid_fifo.read() & 0x7) != 0x2) and ((m_cmd_read_pktid_fifo.read() & 0x7) != 0x6);
    33513155
    3352                     if(entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE)    // hit
    3353                     {
    3354                         if ( (m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE )
     3156                    if (entry.state == ENTRY_SHARED or entry.state == ENTRY_EXCLUSIVE)    // hit
     3157                    {
     3158                        if ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE )
    33553159                        {
    33563160                                // Invalid the line in the others processors and put the line in trt with data.
    3357                                 if(entry.count == 0) 
     3161                                if (entry.count == 0) 
    33583162                                  //  ((entry.count == 1) and not entry.is_cnt and (entry.state == ENTRY_SHARED) and (entry.owner.srcid == m_cmd_read_srcid_fifo.read())) or
    33593163                                  //  (entry.count == 1 and entry.is_cnt and entry.state == ENTRY_SHARED and s_getm_hit))
     
    33633167                                else
    33643168                                {
    3365                                     if((entry.state == ENTRY_EXCLUSIVE) and (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
     3169                                    if ((entry.state == ENTRY_EXCLUSIVE) and (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
    33663170                                    {
    33673171                                        std::cout <<"exclusive line && srcid != read srcid "<< std::endl;
     
    33723176
    33733177                                addr_t min = m_cmd_read_addr_fifo.read();
    3374                                 addr_t max = m_cmd_read_addr_fifo.read() + m_cmd_read_length_fifo.read()*4;
     3178                                addr_t max = m_cmd_read_addr_fifo.read() + m_cmd_read_length_fifo.read() * 4;
    33753179                                m_llsc_table.sw(min, max);
    33763180                        }
    33773181                        else // a read miss request
    33783182                        {
    3379                             if ( entry.state == ENTRY_SHARED or entry.count == 0)
     3183                            if (entry.state == ENTRY_SHARED or entry.count == 0)
    33803184                            {
    3381                                 if( entry.is_cnt or (entry.count == 0) or (not cached_read))
     3185                                if (entry.is_cnt or (entry.count == 0) or (not cached_read))
    33823186                                {
    33833187                                    r_read_fsm = READ_DIR_HIT;
     
    33883192                                }
    33893193                            }
    3390                             else if ( entry.state == ENTRY_EXCLUSIVE )
     3194                            else if (entry.state == ENTRY_EXCLUSIVE)
    33913195                            {
    33923196                                r_read_fsm = READ_IVT_UPDT_LOCK;
     
    33943198                        }
    33953199                    }
    3396                     else if(entry.state == ENTRY_LOCKED) // the line is locked, can't use it at this time
    3397                     {
    3398                         m_cpt_read_locked_rb ++;
     3200                    else if (entry.state == ENTRY_LOCKED) // the line is locked, can't use it at this time
     3201                    {
    33993202                        r_read_fsm = READ_WAIT;
    34003203                    }
     
    34053208
    34063209#if DEBUG_MEMC_READ
    3407                     if(m_debug)
     3210                    if (m_debug)
    34083211                    {
    34093212                        std::cout << "  <MEMC " << name() << " READ_DIR_LOCK> Accessing directory: "
     
    34153218                            << " / is_inst = " << entry.owner.inst
    34163219                            << " / is_cnt = " << entry.is_cnt << std::endl;
    3417                         if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) std::cout << " / LL access" << std::endl;
     3220                        if ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) std::cout << " / LL access" << std::endl;
    34183221                        else                                                std::cout << std::endl;
    34193222                    }
     
    34383241                        size_t ivt_send_count   = 0;
    34393242
    3440                         if( m_ivt.is_full() or // not need to check match inval, because of the LOCKED STATE
     3243                        if (m_ivt.is_full() or // not need to check match inval, because of the LOCKED STATE
    34413244                            r_read_to_cc_send_multi_req.read() or
    34423245                            r_read_to_cc_send_brdcast_req.read() or
     
    34463249                            r_read_fsm = READ_WAIT;
    34473250#if DEBUG_MEMC_READ
    3448                             if(m_debug)
     3251                            if (m_debug)
    34493252                            {
    34503253                                std::cout
     
    34753278                            //r_read_to_cc_send_is_shared     = r_read_state.read() == ENTRY_SHARED;
    34763279
    3477                             if(r_read_need_block.read())
     3280                            if (r_read_need_block.read())
    34783281                            {
    34793282                                r_read_to_cleanup_nline         = nline;
     
    35023305                                      index);
    35033306                               
    3504                             if( not_last_multi_req )
     3307                            if (not_last_multi_req )
    35053308                            {
    35063309                                r_read_fsm = READ_INVAL_HEAP_REQ;
     
    35123315                            }   
    35133316
    3514                             if(multi_req)
    3515                                 m_cpt_getm_minval ++;
    3516                             else
     3317                            // <Activity counters>
     3318                            if (!multi_req)
     3319                            {
    35173320                                m_cpt_getm_broadcast ++;
     3321                            }
     3322                            // </Activity counters>
    35183323#if DEBUG_MEMC_READ
    3519                             if(m_debug)
     3324                            if (m_debug)
    35203325                            {
    35213326                                std::cout
     
    35343339            case READ_INVAL_HEAP_REQ:
    35353340                {
    3536                     if( r_alloc_heap_fsm.read() == ALLOC_HEAP_READ )
     3341                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ )
    35373342                    {
    35383343                        r_read_fsm = READ_INVAL_HEAP_ERASE;
    35393344                    }
    35403345#if DEBUG_MEMC_READ
    3541                     if(m_debug)
     3346                    if (m_debug)
    35423347                        std::cout << "  <MEMC " << name() << " READ_INVAL_HEAP_REQ>"
    35433348                            << " Requesting HEAP lock" << std::endl;
     
    35483353            case READ_INVAL_HEAP_ERASE:
    35493354                {
    3550                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3355                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    35513356                    {
    35523357                        HeapEntry entry = m_heap.read(r_read_next_ptr.read());
     
    35573362                        r_read_next_ptr               = entry.next;
    35583363
    3559                         if(entry.next == r_read_next_ptr.read())   // last copy
     3364                        if (entry.next == r_read_next_ptr.read())   // last copy
    35603365                        {
    35613366                            r_read_to_cc_send_multi_req     = true;
     
    35683373
    35693374#if DEBUG_MEMC_READ
    3570                         if(m_debug)
     3375                        if (m_debug)
    35713376                            std::cout << "  <MEMC " << name() << " READ_HEAP_ERASE>"
    35723377                                << " Erase copy:"
     
    35803385            case READ_INVAL_HEAP_LAST:  // last copy
    35813386                {
    3582                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_READ)
     3387                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_READ)
    35833388                    {
    35843389                        std::cout << "VCI_MEM_CACHE ERROR " << name() << " READ_INVAL_HEAP_LAST"
     
    35913396                    last_entry.owner.srcid    = 0;
    35923397                    last_entry.owner.inst     = false;
    3593                     if(m_heap.is_full())
     3398                    if (m_heap.is_full())
    35943399                    {
    35953400                        last_entry.next     = r_read_next_ptr.read();
     
    36083413
    36093414#if DEBUG_MEMC_READ
    3610                     if(m_debug)
     3415                    if (m_debug)
    36113416                        std::cout << "  <MEMC " << name() << " READ_INVAL_HEAP_LAST>"
    36123417                            << " Heap housekeeping" << std::endl;
     
    36223427                        addr_t nline            = m_nline[(addr_t)(m_cmd_read_addr_fifo.read())];
    36233428                        size_t set              = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    3624                         if( m_ivt.is_full() or
     3429                        if (m_ivt.is_full() or
    36253430                            r_read_to_cc_send_multi_req.read() or
    36263431                            r_read_to_cc_send_brdcast_req.read() or
     
    36293434                            r_read_fsm = READ_WAIT;
    36303435#if DEBUG_MEMC_READ
    3631                             if(m_debug)
     3436                            if (m_debug)
    36323437                            {
    36333438                                std::cout
     
    36523457                            m_cache_directory.write(set, r_read_way.read(), entry);
    36533458                           
    3654                             if(r_read_need_block.read())
     3459                            if (r_read_need_block.read())
    36553460                            {
    36563461                                r_read_to_multi_ack_nline       = nline;
     
    36873492
    36883493#if DEBUG_MEMC_READ
    3689                             if(m_debug)
     3494                            if (m_debug)
    36903495                            {
    36913496                                 std::cout
     
    37093514                    r_read_fsm = READ_DIR_REQ;
    37103515#if DEBUG_MEMC_READ
    3711                     if(m_debug)
     3516                    if (m_debug)
    37123517                    {
    37133518                        std::cout
     
    37473552                    DirectoryEntry entry;
    37483553
    3749                     if(inst_read)
     3554                    if (inst_read)
    37503555                    {
    37513556                        entry.state = ENTRY_SHARED;
    37523557                    }
    3753                     else if(is_getm)
     3558                    else if (is_getm)
    37543559                    {
    37553560                        entry.state = ENTRY_EXCLUSIVE;
     
    37613566 
    37623567                    //entry.cache_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
    3763                     if( entry.state == ENTRY_SHARED) r_read_shared = true;
     3568                    if (entry.state == ENTRY_SHARED) r_read_shared = true;
    37643569                        else    r_read_shared = false;
    37653570                    entry.is_cnt  = is_cnt;
     
    37683573                    entry.lock    = r_read_lock.read();
    37693574                    entry.ptr     = r_read_ptr.read();
    3770                     if(cached_read)   // Cached read => we must update the copies
    3771                     {
    3772                         if(is_getm)
     3575                    if (cached_read)   // Cached read => we must update the copies
     3576                    {
     3577                        if (is_getm)
    37733578                        {
    37743579                            entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     
    37773582 
    37783583                        }
    3779                         else if(!is_cnt)  // Not counter mode
     3584                        else if (!is_cnt)  // Not counter mode
    37803585                        {
    37813586                            entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     
    37983603
    37993604#if DEBUG_MEMC_READ
    3800                     if(m_debug)
     3605                    if (m_debug)
    38013606                        std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    38023607                            << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
     
    38183623            case READ_HEAP_REQ:    // Get the lock to the HEAP directory
    38193624                {
    3820                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3625                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    38213626                    {
    38223627                        r_read_fsm = READ_HEAP_LOCK;
    3823                         m_cpt_read_fsm_n_heap_lock++;
    38243628                    }
    38253629
    38263630#if DEBUG_MEMC_READ
    3827                     if(m_debug)
     3631                    if (m_debug)
    38283632                        std::cout << "  <MEMC " << name() << " READ_HEAP_REQ>"
    38293633                            << " Requesting HEAP lock " << std::endl;
    38303634#endif
    3831 
    3832                     m_cpt_read_fsm_heap_lock++;
    3833 
    38343635                    break;
    38353636                }
     
    38393640                // and prepare the HEAP update
    38403641                {
    3841                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3642                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    38423643                    {
    38433644                        // enter counter mode when we reach the limit of copies or the heap is full
     
    38623663                        r_read_shared = true;  //ack to cache L1 with shared state
    38633664   
    3864                         if(not go_cnt)         // Not entering counter mode
     3665                        if (not go_cnt)         // Not entering counter mode
    38653666                        {
    38663667                            entry.owner.srcid    = r_read_copy.read();
     
    38783679
    38793680                        // prepare the heap update (add an entry, or clear the linked list)
    3880                         if(not go_cnt)      // not switching to counter mode
     3681                        if (not go_cnt)      // not switching to counter mode
    38813682                        {
    38823683                            // We test if the next free entry in the heap is the last
     
    38893690                        else            // switching to counter mode
    38903691                        {
    3891                             if(r_read_count.read() >1)              // heap must be cleared
     3692                            if (r_read_count.read() >1)              // heap must be cleared
    38923693                            {
    38933694                                HeapEntry next_entry = m_heap.read(r_read_ptr.read());
     
    38953696                                m_heap.write_free_ptr(r_read_ptr.read());
    38963697
    3897                                 if(next_entry.next == r_read_ptr.read())    // last entry
     3698                                if (next_entry.next == r_read_ptr.read())    // last entry
    38983699                                {
    38993700                                    r_read_fsm = READ_HEAP_LAST;    // erase the entry
     
    39123713
    39133714#if DEBUG_MEMC_READ
    3914                         if(m_debug)
     3715                        if (m_debug)
    39153716                            std::cout << "  <MEMC " << name() << " READ_HEAP_LOCK> Update directory:"
    39163717                                << " tag = " << std::hex << entry.tag
     
    39323733            case READ_HEAP_WRITE:       // add an entry in the heap
    39333734                {
    3934                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3735                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    39353736                    {
    39363737                        HeapEntry heap_entry;
     
    39383739                        heap_entry.owner.inst     = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    39393740
    3940                         if(r_read_count.read() == 1)  // creation of a new linked list
     3741                        if (r_read_count.read() == 1)  // creation of a new linked list
    39413742                        {
    39423743                            heap_entry.next         = m_heap.next_free_ptr();
     
    39483749                        m_heap.write_free_entry(heap_entry);
    39493750                        m_heap.write_free_ptr(r_read_next_ptr.read());
    3950                         if(r_read_last_free.read())  m_heap.set_full();
     3751                        if (r_read_last_free.read())  m_heap.set_full();
    39513752
    39523753                        r_read_fsm    = READ_RSP;
    39533754
    39543755#if DEBUG_MEMC_READ
    3955                         if(m_debug)
     3756                        if (m_debug)
    39563757                            std::cout << "  <MEMC " << name() << " READ_HEAP_WRITE> Add an entry in the heap:"
    39573758                                << " owner_id = " << std::hex << heap_entry.owner.srcid
     
    39703771            case READ_HEAP_ERASE:
    39713772                {
    3972                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3773                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    39733774                    {
    39743775                        HeapEntry next_entry = m_heap.read(r_read_ptr.read());
    3975                         if(next_entry.next == r_read_ptr.read())
     3776                        if (next_entry.next == r_read_ptr.read())
    39763777                        {
    39773778                            r_read_fsm = READ_HEAP_LAST;
     
    39953796            case READ_HEAP_LAST:
    39963797                {
    3997                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
     3798                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_READ)
    39983799                    {
    39993800                        HeapEntry last_entry;
     
    40013802                        last_entry.owner.inst     = false;
    40023803
    4003                         if(m_heap.is_full())
     3804                        if (m_heap.is_full())
    40043805                        {
    40053806                            last_entry.next       = r_read_ptr.read();
     
    40243825            case READ_RSP:    //  request the TGT_RSP FSM to return data
    40253826                {
    4026                     if(not r_read_to_tgt_rsp_req.read())
     3827                    if (not r_read_to_tgt_rsp_req.read())
    40273828                    {
    40283829                        for(size_t i=0 ; i<m_words ; i++)  r_read_to_tgt_rsp_data[i] = r_read_data[i];
     
    40463847
    40473848#if DEBUG_MEMC_READ
    4048                         if(m_debug)
     3849                        if (m_debug)
    40493850                            std::cout << "  <MEMC " << name() << " READ_RSP> Request TGT_RSP FSM to return data:"
    40503851                                << " rsrcid = " << std::hex << m_cmd_read_srcid_fifo.read()
     
    40583859            case READ_TRT_LOCK: // read miss : check the Transaction Table
    40593860                {
    4060                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
     3861                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
    40613862                    {
    40623863                        size_t      index     = 0;
     
    40673868                        bool        wok       = !m_trt.full(index);
    40683869                       
    4069                         //if(hit_write) m_trt.print(index_write);
    4070                         if(hit_read or !wok or hit_write)    // missing line already requested or no space
    4071                         {
    4072                             if(!wok)
     3870                        //if (hit_write) m_trt.print(index_write);
     3871                        if (hit_read or !wok or hit_write)    // missing line already requested or no space
     3872                        {
     3873                            // <Activity counters>
     3874                            if (!wok)
    40733875                            {
    40743876                                m_cpt_trt_full++;
    40753877                            }
    4076                             if(hit_read or hit_write)   m_cpt_trt_rb++;
     3878                            if (hit_read or hit_write)
     3879                            {
     3880                                m_cpt_trt_rb++;
     3881                            }
     3882                            // </Activity counters>
    40773883                            r_read_fsm = READ_IDLE;
    40783884                        }
    4079                         else                  // missing line is requested to the XRAM
    4080                         {
    4081 
    4082                             if ( (m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE )
    4083                                 m_cpt_getm_miss ++;
    4084                             else
     3885                        else // missing line is requested to the XRAM
     3886                        {
     3887
     3888                            // <Activity counters>
     3889                            if ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_WRITE) {
     3890                                m_cpt_getm_miss++;
     3891                            }
     3892                            else {
    40853893                                m_cpt_read_miss++;
     3894                            }
     3895                            // </Activity counters>
    40863896
    40873897                            r_read_trt_index = index;
     
    40903900
    40913901#if DEBUG_MEMC_READ
    4092                         if(m_debug)
     3902                        if (m_debug)
    40933903                            std::cout << "  <MEMC " << name() << " READ_TRT_LOCK> Check TRT:"
    40943904                                << " hit_read = " << hit_read
    40953905                                << " / hit_write = " << hit_write
    40963906                                << " / full = " << !wok << std::endl;
    4097                         m_cpt_read_fsm_n_trt_lock++;
    4098 #endif
    4099                     }
    4100 
    4101                     m_cpt_read_fsm_trt_lock++;
    4102 
     3907#endif
     3908                    }
    41033909                    break;
    41043910                }
     
    41073913            case READ_TRT_SET:      // register get transaction in TRT
    41083914                {
    4109                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
     3915                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_READ)
    41103916                    {
    41113917                        m_trt.set(r_read_trt_index.read(),
     
    41233929
    41243930#if DEBUG_MEMC_READ
    4125                         if(m_debug)
     3931                        if (m_debug)
    41263932                            std::cout << "  <MEMC " << name() << " READ_TRT_SET> Set a GET in TGT:"
    41273933                                << " address = " << std::hex << m_cmd_read_addr_fifo.read()
     
    41363942            case READ_TRT_REQ:   // consume the read request in FIFO and send it to IXR_CMD_FSM
    41373943                {
    4138                     if(not r_read_to_ixr_cmd_req)
     3944                    if (not r_read_to_ixr_cmd_req)
    41393945                    {
    41403946                        cmd_read_fifo_get       = true;
     
    41453951
    41463952#if DEBUG_MEMC_READ
    4147                         if(m_debug)
     3953                        if (m_debug)
    41483954                            std::cout << "  <MEMC " << name() << " READ_TRT_REQ> Request GET transaction for address "
    41493955                                << std::hex << m_cmd_read_addr_fifo.read() << std::endl;
     
    42174023                    for(size_t word=0 ; word<m_words ; word++)
    42184024                    {
    4219                         if(word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
     4025                        if (word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
    42204026                        else              r_write_be[word] = 0x0;
    42214027                    }
     
    42314037
    42324038#if DEBUG_MEMC_WRITE
    4233                     if(m_debug)
     4039                    if (m_debug)
    42344040                        std::cout << "  <MEMC " << name() << " WRITE_IDLE> Write request "
    42354041                            << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
     
    42954101                    if (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE )
    42964102                    {
    4297                         m_cpt_write_fsm_n_dir_lock ++;
    42984103                        break;
    42994104                    }
     
    43264131                    }
    43274132
    4328                     m_cpt_write_fsm_dir_lock ++;
    4329 
    43304133#if DEBUG_MEMC_WRITE
    4331                     if(m_debug)
     4134                    if (m_debug)
    43324135                        std::cout << "  <MEMC " << name() << " WRITE_DIR_REQ> Requesting DIR lock "
    43334136                            << std::endl;
     
    43444147                    DirectoryEntry entry(m_cache_directory.read(r_write_address.read(), way));
    43454148
    4346                     if(entry.state != ENTRY_INVALID)    // hit
     4149                    if (entry.state != ENTRY_INVALID)    // hit
    43474150                    {
    43484151                        // copy directory entry in local buffer in case of hit
     
    43574160                        r_write_state      = entry.state;
    43584161
    4359                         if( r_write_pktid == TYPE_DATA_UNC and entry.count != 0)
     4162                        if (r_write_pktid == TYPE_DATA_UNC and entry.count != 0)
    43604163                        {
    43614164                            assert( false && " found a copy for an uncached write quest");
     
    43634166                        else
    43644167                        {
    4365                             if( not entry.count and (entry.state != ENTRY_LOCKED))
     4168                            if (not entry.count and (entry.state != ENTRY_LOCKED))
    43664169                            {
    43674170                                r_write_fsm = WRITE_DIR_HIT;   
     
    43694172                            else if (entry.state == ENTRY_LOCKED)//the line is locked
    43704173                            {
    4371                                 m_cpt_write_locked_rb ++;
    43724174                                r_write_fsm = WRITE_WAIT;
    43734175                            }
     
    43844186
    43854187#if DEBUG_MEMC_WRITE
    4386                     if(m_debug)
     4188                    if (m_debug)
    43874189                    {
    43884190                        std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> Check the directory: "
     
    43914193                            << " / count = " << entry.count
    43924194                            << " / is_cnt = " << entry.is_cnt ;
    4393                         if((r_write_pktid.read() & 0x7) == TYPE_SC)
     4195                        if ((r_write_pktid.read() & 0x7) == TYPE_SC)
    43944196                            std::cout << " / SC access" << std::endl;
    43954197                        else
     
    44394241
    44404242#if DEBUG_MEMC_WRITE
    4441                     if(m_debug)
     4243                    if (m_debug)
    44424244                    {
    44434245                         std::cout << "  <MEMC " << name()
     
    44514253            case WRITE_HEAP_REQ:    // Get the lock to the HEAP directory
    44524254                {
    4453                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
     4255                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
    44544256                    {
    44554257                        r_write_fsm = WRITE_HEAP_ERASE;
    4456                         m_cpt_write_fsm_n_heap_lock++;
    44574258                    }
    44584259
    44594260#if DEBUG_MEMC_WRITE
    4460                     if(m_debug)
     4261                    if (m_debug)
    44614262                        std::cout << "  <MEMC " << name() << " WRITE_HEAP_REQ>"
    44624263                            << " Requesting HEAP lock " << std::endl;
    44634264#endif
    4464 
    4465                     m_cpt_write_fsm_heap_lock++;
    4466 
    44674265                    break;
    44684266                }
     
    44714269            case WRITE_HEAP_ERASE:   // get access to heap
    44724270                {
    4473                     if(r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
     4271                    if (r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE)
    44744272                    {
    44754273                        HeapEntry entry = m_heap.read(r_write_next_ptr.read());
     
    44784276                        write_to_cc_send_fifo_inst     = entry.owner.inst;
    44794277                        write_to_cc_send_fifo_put      = true;
    4480                         if(m_write_to_cc_send_inst_fifo.wok())
     4278                        if (m_write_to_cc_send_inst_fifo.wok())
    44814279                        {
    44824280                            r_write_next_ptr = entry.next;
    4483                             if(entry.next == r_write_next_ptr.read())   // last copy
     4281                            if (entry.next == r_write_next_ptr.read())   // last copy
    44844282                            {
    44854283                                r_write_to_cc_send_multi_req = true;
     
    44974295
    44984296#if DEBUG_MEMC_WRITE
    4499                         if(m_debug)
     4297                        if (m_debug)
    45004298                            std::cout << "  <MEMC " << name()
    45014299                                << " WRITE_HEAP_LOCK> Get acces to the HEAP" << std::endl;
    45024300#endif
    45034301                    }
    4504 
    4505                     m_cpt_write_fsm_heap_lock++;
    4506 
    45074302                    break;
    45084303                }
     
    45104305            case WRITE_HEAP_LAST:  // last copy
    45114306                {
    4512                     if(r_alloc_heap_fsm.read() != ALLOC_HEAP_WRITE)
     4307                    if (r_alloc_heap_fsm.read() != ALLOC_HEAP_WRITE)
    45134308                    {
    45144309                        std::cout << "VCI_MEM_CACHE ERROR " << name() << " WRITE_HEAP_LAST"
     
    45214316                    last_entry.owner.srcid    = 0;
    45224317                    last_entry.owner.inst     = false;
    4523                     if(m_heap.is_full())
     4318                    if (m_heap.is_full())
    45244319                    {
    45254320                        last_entry.next     = r_write_next_ptr.read();
     
    45374332
    45384333#if DEBUG_MEMC_XRAM_RSP
    4539                     if(m_debug)
     4334                    if (m_debug)
    45404335                        std::cout << "  <MEMC " << name() << " WRITE_HEAP_LAST>"
    45414336                            << " Heap housekeeping" << std::endl;
     
    45924387                            for(size_t word=0 ; word<m_words ; word++)
    45934388                            {
    4594                                 if(word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
     4389                                if (word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
    45954390                                else              r_write_be[word] = 0x0;
    45964391                            }
    45974392
    4598                             if( m_cmd_write_eop_fifo.read())
     4393                            if (m_cmd_write_eop_fifo.read())
    45994394                            {
    46004395                                r_write_fsm = WRITE_DIR_REQ;
     
    46074402
    46084403#if DEBUG_MEMC_WRITE
    4609                         if(m_debug)
     4404                        if (m_debug)
    46104405                        {
    46114406                            std::cout << "  <MEMC " << name() << " WRITE_RSP> Post a request to TGT_RSP FSM"
     
    46144409                                << " : sc_fail= " << std::hex << r_write_sc_fail.read()
    46154410                                << std::endl;
    4616                             if(m_cmd_write_addr_fifo.rok())
     4411                            if (m_cmd_write_addr_fifo.rok())
    46174412                            {
    46184413                                std::cout << "                    New Write request: "
     
    46314426            case WRITE_MISS_TRT_LOCK: // Miss : check Transaction Table
    46324427                {
    4633                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
     4428                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    46344429                    {
    46354430                        size_t  hit_index = 0;
     
    46404435                        bool    wok       = not m_trt.full(wok_index);
    46414436#if DEBUG_MEMC_WRITE
    4642                         if(m_debug)
     4437                        if (m_debug)
    46434438                            std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_LOCK> Check the TRT"
    46444439                                      << "hit read =" << hit_read
     
    46494444
    46504445                        // wait an empty entry in TRT
    4651                         if(not hit_read and (not wok or hit_write))
     4446                        if (not hit_read and (not wok or hit_write))
    46524447                        {
    46534448                            r_write_fsm       = WRITE_WAIT;
     4449                            // <Activity counters>
    46544450                            m_cpt_trt_full++;
    4655 
     4451                            // </Activity counters>
    46564452                            break;
    46574453                        }
     
    46684464                            r_write_trt_index = hit_index;
    46694465                            r_write_fsm       = WRITE_MISS_TRT_DATA;
     4466                            // <Activity counters>
    46704467                            m_cpt_write_miss++;
     4468                            // </Activity counters>
    46714469                            break;
    46724470                        }
     
    46764474                            r_write_trt_index = wok_index;
    46774475                            r_write_fsm       = WRITE_MISS_TRT_SET;
     4476                            // <Activity counters>
    46784477                            m_cpt_write_miss++;
     4478                            // </Activity counters>
    46794479                            break;
    46804480                        }
    46814481
    4682                         m_cpt_write_fsm_n_trt_lock ++;
    46834482                        assert(false && "VCI_MEM_CACHE ERROR: this part must not be reached");
    46844483                    }
     
    46924491
    46934492#if DEBUG_MEMC_WRITE
    4694                     if(m_debug)
     4493                    if (m_debug)
    46954494                        std::cout << "  <MEMC " << name() << " WRITE_WAIT> Releases the locks before retry" << std::endl;
    46964495#endif
     
    47024501            case WRITE_MISS_TRT_SET:  // register a new transaction in TRT (Write Buffer)
    47034502                {
    4704                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
     4503                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    47054504                    {
    47064505                        std::vector<be_t>   be_vector;
     
    47274526
    47284527#if DEBUG_MEMC_WRITE
    4729                         if(m_debug)
     4528                        if (m_debug)
    47304529                            std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_SET> Set a new entry in TRT" << std::endl;
    47314530#endif
     
    47374536            case WRITE_MISS_TRT_DATA: // update an entry in TRT (used as a Write Buffer)
    47384537                {
    4739                     if(r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
     4538                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_WRITE)
    47404539                    {
    47414540                        std::vector<be_t> be_vector;
     
    47544553
    47554554#if DEBUG_MEMC_WRITE
    4756                         if(m_debug)
     4555                        if (m_debug)
    47574556                            std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_DATA> Modify an existing entry in TRT" << std::endl;
    47584557#endif
     
    47644563            case WRITE_MISS_XRAM_REQ: // send a GET request to IXR_CMD FSM
    47654564                {
    4766                     if(not r_write_to_ixr_cmd_req.read())
     4565                    if (not r_write_to_ixr_cmd_req.read())
    47674566                    {
    47684567                        r_write_to_ixr_cmd_req   = true;
     
    47714570
    47724571#if DEBUG_MEMC_WRITE
    4773                         if(m_debug)
     4572                        if (m_debug)
    47744573                            std::cout << "  <MEMC " << name()
    47754574                                << " WRITE_MISS_XRAM_REQ> Post a GET request to the"
     
    47964595                                           // (r_write_inval_trt_send.read() or not r_write_to_cleanup_req.read());
    47974596
    4798                     if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
     4597                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    47994598                    {
    48004599                        bool        wok        = false;
     
    48104609                        //r_write_ivt_index = index;
    48114610
    4812                         if(not ivt_full and cc_send_valid) //avoid to deadlock, we make sure that we can send cc_send request.
     4611                        if (not ivt_full and cc_send_valid) //avoid to deadlock, we make sure that we can send cc_send request.
    48134612                        { 
    48144613                            wok = m_ivt.set(false,        // it's an inval transaction
     
    48244623                                            index);
    48254624
    4826                             if(is_brdcast)
    4827                                 m_cpt_write_broadcast ++;
    4828                             else
    4829                                 m_cpt_write_minval ++;
     4625                            // <Activity counters>
     4626                            if (is_brdcast)
     4627                            {
     4628                                m_cpt_write_broadcast++;
     4629                            }
     4630                            // </Activity counters>
     4631
    48304632#if DEBUG_MEMC_WRITE
    4831                         if( m_debug and wok )
     4633                        if (m_debug and wok )
    48324634                            std::cout << "  <MEMC " << name() << " WRITE_INVAL_IVT_LOCK> Register broadcast inval in IVT"
    48334635                                << "ivt index = " << index
     
    48564658                            {
    48574659                               
    4858                                 if(r_write_state.read() == ENTRY_SHARED)
     4660                                if (r_write_state.read() == ENTRY_SHARED)
    48594661                                {
    48604662                                    m_cache_data.write(way, set, word, r_write_data[word].read(), r_write_be[word].read());
     
    48804682            case WRITE_INVAL_CC_SEND:    // Post a coherence broadcast request to CC_SEND FSM
    48814683                {
    4882                     if( not r_write_to_cc_send_multi_req.read()   and
     4684                    if (not r_write_to_cc_send_multi_req.read()   and
    48834685                        not r_write_to_cc_send_brdcast_req.read())
    48844686                    {
     
    48944696                        r_write_next_ptr               = r_write_ptr.read();
    48954697
    4896                         if(r_write_state.read() == ENTRY_EXCLUSIVE)
     4698                        if (r_write_state.read() == ENTRY_EXCLUSIVE)
    48974699                        {
    48984700                            r_write_to_cleanup_req   = true;
     
    49004702                        }
    49014703
    4902                         if( not last_multi_inval and multi_inval)
     4704                        if (not last_multi_inval and multi_inval)
    49034705                        {
    49044706                            r_write_fsm = WRITE_HEAP_REQ;
     
    49094711                        }
    49104712#if DEBUG_MEMC_WRITE
    4911                         if(m_debug)
     4713                        if (m_debug)
    49124714                            std::cout << "  <MEMC " << name()
    49134715                                << " WRITE_INVAL_CC_SEND> Post a inval request to CC_SEND FSM" << std::endl;
     
    49484750            case IXR_CMD_READ_IDLE:
    49494751                if     (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4950                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4951                 else if(r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4952                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4953                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4954                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4752                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4753                else if (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4754                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4755                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4756                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    49554757                break;
    49564758                ////////////////////////
    49574759            case IXR_CMD_WRITE_IDLE:
    49584760                if     (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4959                 else if(r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4960                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4961                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4962                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4963                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4761                else if (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4762                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4763                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4764                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4765                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    49644766                break;
    49654767                ////////////////////////
    49664768            case IXR_CMD_CAS_IDLE:
    49674769                if     (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4968                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4969                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4970                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4971                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4972                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4770                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4771                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4772                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4773                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4774                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    49734775                break;
    49744776                ////////////////////////
    49754777            case IXR_CMD_XRAM_IDLE:
    49764778                if     (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4977                 else if(r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4978                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4979                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4980                 else if(r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4981                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4779                else if (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
     4780                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4781                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4782                else if (r_cleanup_to_ixr_cmd_req.read())    r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4783                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    49824784                break;
    49834785                ////////////////////////
    49844786            case IXR_CMD_CLEANUP_IDLE:
    49854787                if     (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4986                 else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4987                 else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4988                 else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    4989                 else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    4990                 else if(r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4788                else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4789                else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4790                else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4791                else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4792                else if (r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    49914793                break;     
    49924794                /////////////////////////
     
    49944796                {
    49954797                    if     (r_read_to_ixr_cmd_req.read())       r_ixr_cmd_fsm = IXR_CMD_READ_TRT;
    4996                     else if(r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
    4997                     else if(r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
    4998                     else if(r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4999                     else if(r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
    5000                     else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
     4798                    else if (r_write_to_ixr_cmd_req.read())      r_ixr_cmd_fsm = IXR_CMD_WRITE_TRT;
     4799                    else if (r_cas_to_ixr_cmd_req.read())        r_ixr_cmd_fsm = IXR_CMD_CAS_TRT;
     4800                    else if (r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
     4801                    else if (r_xram_rsp_to_ixr_cmd_req.read())   r_ixr_cmd_fsm = IXR_CMD_XRAM_TRT;
     4802                    else if (r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    50014803                    break;
    50024804                }
     
    50054807            case IXR_CMD_READ_TRT:       // access TRT for a GET
    50064808                {
    5007                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4809                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50084810                    {
    50094811                        TransactionTabEntry entry = m_trt.read( r_read_to_ixr_cmd_index.read() );
     
    50154817
    50164818#if DEBUG_MEMC_IXR_CMD
    5017                         if(m_debug)
     4819                        if (m_debug)
    50184820                            std::cout << "  <MEMC " << name() << " IXR_CMD_READ_TRT> TRT access"
    50194821                                << " index = " << std::dec << r_read_to_ixr_cmd_index.read()
     
    50264828            case IXR_CMD_WRITE_TRT:       // access TRT for a PUT or a GET
    50274829                {
    5028                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4830                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50294831                    {
    50304832                        TransactionTabEntry entry = m_trt.read( r_write_to_ixr_cmd_index.read() );
     
    50424844
    50434845#if DEBUG_MEMC_IXR_CMD
    5044                         if(m_debug)
     4846                        if (m_debug)
    50454847                            std::cout << "  <MEMC " << name() << " IXR_CMD_WRITE_TRT> TRT access"
    50464848                                << " index = " << std::dec << r_write_to_ixr_cmd_index.read()
     
    50534855            case IXR_CMD_CAS_TRT:       // access TRT for a PUT or a GET
    50544856                {
    5055                     if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
     4857                    if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    50564858                    {
    50574859                        TransactionTabEntry entry = m_trt.read( r_cas_to_ixr_cmd_index.read() );
     
    50694871
    50704872#if DEBUG_MEMC_IXR_CMD
    5071                         if(m_debug)
     4873                        if (m_debug)
    50724874                            std::cout << "  <MEMC " << name() << " IXR_CMD_CAS_TRT> TRT access"
    50734875                                << " index = " << std::dec << r_cas_to_ixr_cmd_index.read()