Changeset 787 for branches


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

RWT branch:

  • Cleaning counters
Location:
branches/RWT/modules/vci_mem_cache/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r783 r787  
    494494      uint32_t m_cpt_put;
    495495
    496       // TODO: clean the following counters (not necessarily useful and well-implemented)
    497       uint32_t m_cpt_read_fsm_dir_lock;        // wait DIR LOCK
    498       uint32_t m_cpt_read_fsm_n_dir_lock;      // NB DIR LOCK
    499       uint32_t m_cpt_write_fsm_dir_lock;       // wait DIR LOCK
    500       uint32_t m_cpt_write_fsm_n_dir_lock;     // NB DIR LOCK
    501       uint32_t m_cpt_xram_rsp_fsm_dir_lock;    // wait DIR LOCK
    502       uint32_t m_cpt_xram_rsp_fsm_n_dir_lock;  // NB DIR LOCK
    503       uint32_t m_cpt_cas_fsm_dir_lock;         // wait DIR LOCK
    504       uint32_t m_cpt_cas_fsm_n_dir_lock;       // NB DIR LOCK
    505       uint32_t m_cpt_cleanup_fsm_dir_lock;     // wait DIR LOCK
    506       uint32_t m_cpt_cleanup_fsm_n_dir_lock;   // NB DIR LOCK
    507      
    508       uint32_t m_cpt_dir_unused;            // NB cycles DIR LOCK unused
    509       uint32_t m_cpt_read_fsm_dir_used;     // NB cycles DIR LOCK used
    510       uint32_t m_cpt_write_fsm_dir_used;    // NB cycles DIR LOCK used
    511       uint32_t m_cpt_cas_fsm_dir_used;      // NB cycles DIR LOCK used
    512       uint32_t m_cpt_xram_rsp_fsm_dir_used; // NB cycles DIR LOCK used
    513       uint32_t m_cpt_cleanup_fsm_dir_used;  // NB cycles DIR LOCK used
    514 
    515       uint32_t m_cpt_read_fsm_trt_lock;      // wait TRT LOCK
    516       uint32_t m_cpt_write_fsm_trt_lock;     // wait TRT LOCK
    517       uint32_t m_cpt_cas_fsm_trt_lock;       // wait TRT LOCK
    518       uint32_t m_cpt_xram_rsp_fsm_trt_lock;  // wait TRT LOCK
    519       uint32_t m_cpt_ixr_fsm_trt_lock;       // wait TRT LOCK
    520      
    521       uint32_t m_cpt_read_fsm_n_trt_lock;      // NB TRT LOCK
    522       uint32_t m_cpt_write_fsm_n_trt_lock;     // NB TRT LOCK
    523       uint32_t m_cpt_cas_fsm_n_trt_lock;       // NB TRT LOCK
    524       uint32_t m_cpt_xram_rsp_fsm_n_trt_lock;  // NB TRT LOCK
    525       uint32_t m_cpt_ixr_fsm_n_trt_lock;       // NB TRT LOCK
    526 
    527       uint32_t m_cpt_read_fsm_trt_used;      // NB cycles TRT LOCK used
    528       uint32_t m_cpt_write_fsm_trt_used;     // NB cycles TRT LOCK used
    529       uint32_t m_cpt_cas_fsm_trt_used;       // NB cycles TRT LOCK used
    530       uint32_t m_cpt_xram_rsp_fsm_trt_used;  // NB cycles TRT LOCK used
    531       uint32_t m_cpt_ixr_fsm_trt_used;       // NB cycles TRT LOCK used
    532      
    533       uint32_t m_cpt_trt_unused;            // NB cycles TRT LOCK unused
    534 
    535       uint32_t m_cpt_write_fsm_upt_lock;     // wait UPT LOCK
    536       uint32_t m_cpt_xram_rsp_fsm_upt_lock;  // wait UPT LOCK
    537       uint32_t m_cpt_multi_ack_fsm_upt_lock; // wait UPT LOCK
    538       uint32_t m_cpt_cleanup_fsm_ivt_lock;   // wait UPT LOCK
    539       uint32_t m_cpt_cas_fsm_upt_lock;       // wait UPT LOCK
    540      
    541       uint32_t m_cpt_write_fsm_n_upt_lock;     // NB UPT LOCK
    542       uint32_t m_cpt_xram_rsp_fsm_n_upt_lock;  // NB UPT LOCK
    543       uint32_t m_cpt_multi_ack_fsm_n_upt_lock; // NB UPT LOCK
    544       uint32_t m_cpt_cleanup_fsm_n_upt_lock;   // NB UPT LOCK
    545       uint32_t m_cpt_cas_fsm_n_upt_lock;       // NB UPT LOCK
    546      
    547       uint32_t m_cpt_write_fsm_upt_used;     // NB cycles UPT LOCK used
    548       uint32_t m_cpt_xram_rsp_fsm_upt_used;  // NB cycles UPT LOCK used
    549       uint32_t m_cpt_multi_ack_fsm_upt_used; // NB cycles UPT LOCK used
    550       uint32_t m_cpt_cleanup_fsm_ivt_used;   // NB cycles UPT LOCK used
    551       uint32_t m_cpt_cas_fsm_upt_used;       // NB cycles UPT LOCK used
    552      
    553       uint32_t m_cpt_ivt_unused;            // NB cycles UPT LOCK unused
    554       uint32_t m_cpt_upt_unused;            // NB cycles UPT LOCK unused
    555 
    556       uint32_t m_cpt_read_fsm_heap_lock;     // wait HEAP LOCK
    557       uint32_t m_cpt_write_fsm_heap_lock;    // wait HEAP LOCK
    558       uint32_t m_cpt_cas_fsm_heap_lock;      // wait HEAP LOCK
    559       uint32_t m_cpt_cleanup_fsm_heap_lock;  // wait HEAP LOCK
    560       uint32_t m_cpt_xram_rsp_fsm_heap_lock; // wait HEAP LOCK
    561      
    562       uint32_t m_cpt_read_fsm_n_heap_lock;     // NB HEAP LOCK
    563       uint32_t m_cpt_write_fsm_n_heap_lock;    // NB HEAP LOCK
    564       uint32_t m_cpt_cas_fsm_n_heap_lock;      // NB HEAP LOCK
    565       uint32_t m_cpt_cleanup_fsm_n_heap_lock;  // NB HEAP LOCK
    566       uint32_t m_cpt_xram_rsp_fsm_n_heap_lock; // NB HEAP LOCK
    567      
    568       uint32_t m_cpt_read_fsm_heap_used;     // NB cycles HEAP LOCK used
    569       uint32_t m_cpt_write_fsm_heap_used;    // NB cycles HEAP LOCK used
    570       uint32_t m_cpt_cas_fsm_heap_used;      // NB cycles HEAP LOCK used
    571       uint32_t m_cpt_cleanup_fsm_heap_used;  // NB cycles HEAP LOCK used
    572       uint32_t m_cpt_xram_rsp_fsm_heap_used; // NB cycles HEAP LOCK used
    573      
     496      uint32_t m_cpt_dir_unused; // NB cycles DIR LOCK unused
     497      uint32_t m_cpt_trt_unused; // NB cycles TRT LOCK unused
     498      uint32_t m_cpt_ivt_unused; // NB cycles UPT LOCK unused
     499      uint32_t m_cpt_upt_unused; // NB cycles UPT LOCK unused
     500
     501      // Unused
    574502      uint32_t m_cpt_read_data_unc;
    575503      uint32_t m_cpt_read_data_miss_CC;

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

    r783 r787  
    846846    {
    847847        m_cpt_reset_count         = m_cpt_cycles;
     848
    848849        m_cpt_read_local          = 0;
    849850        m_cpt_read_remote         = 0;
    850851        m_cpt_read_cost           = 0;
     852
    851853        m_cpt_write_local         = 0;
    852854        m_cpt_write_remote        = 0;
    … …  
    855857        m_cpt_write_cost          = 0;
    856858        m_cpt_write_ncc_miss      = 0;
     859
    857860        m_cpt_ll_local            = 0;
    858861        m_cpt_ll_remote           = 0;
    859862        m_cpt_ll_cost             = 0;
     863
    860864        m_cpt_sc_local            = 0;
    861865        m_cpt_sc_remote           = 0;
    862866        m_cpt_sc_cost             = 0;
     867
    863868        m_cpt_cas_local           = 0;
    864869        m_cpt_cas_remote          = 0;
    865870        m_cpt_cas_cost            = 0;
     871
    866872        m_cpt_update              = 0;
    867873        m_cpt_update_local        = 0;
    868874        m_cpt_update_remote       = 0;
    869875        m_cpt_update_cost         = 0;
     876       
    870877        m_cpt_minval              = 0;
    871878        m_cpt_minval_local        = 0;
    872879        m_cpt_minval_remote       = 0;
    873880        m_cpt_minval_cost         = 0;
     881
    874882        m_cpt_binval              = 0;
    875883        m_cpt_write_broadcast     = 0;
     884
    876885        m_cpt_cleanup_local       = 0;
    877886        m_cpt_cleanup_remote      = 0;
    878887        m_cpt_cleanup_cost        = 0;
     888        m_cpt_cleanup_data_local  = 0;
     889        m_cpt_cleanup_data_remote = 0;
     890        m_cpt_cleanup_data_cost   = 0;
     891
    879892        m_cpt_read_miss           = 0;
    880893        m_cpt_write_miss          = 0;
    881894        m_cpt_write_dirty         = 0;
     895       
    882896        m_cpt_trt_rb              = 0;
    883897        m_cpt_trt_full            = 0;
    884898        m_cpt_get                 = 0;
    885899        m_cpt_put                 = 0;
     900
    886901        m_cpt_ncc_to_cc_read      = 0;
    887902        m_cpt_ncc_to_cc_write     = 0;
    888         m_cpt_cleanup_data_local  = 0;
    889         m_cpt_cleanup_data_remote = 0;
    890         m_cpt_cleanup_data_cost   = 0;
    891903    }
    892904
    … …  
    941953                << "[080] BROADCAT INVAL            = " << m_cpt_binval << std::endl
    942954                << "[081] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     955                << "[082] GETM BROADCAST            = " << "0" << std::endl
    943956                << std::endl
    944957                << "[090] LOCAL CLEANUP             = " << m_cpt_cleanup_local << std::endl
    … …  
    952965                << "[101] WRITE MISS                = " << m_cpt_write_miss << std::endl
    953966                << "[102] WRITE DIRTY               = " << m_cpt_write_dirty << std::endl
     967                << "[103] GETM MISS                 = " << "0" << std::endl
    954968                << std::endl
    955969                << "[110] RD BLOCKED BY HIT IN TRT  = " << m_cpt_trt_rb << std::endl
    … …  
    961975                << "[140] NCC TO CC (READ)          = " << m_cpt_ncc_to_cc_read << std::endl
    962976                << "[141] NCC TO CC (WRITE)         = " << m_cpt_ncc_to_cc_write << std::endl
     977                << std::endl
     978                << "[150] LOCAL GETM                = " << "0" << std::endl
     979                << "[151] REMOTE GETM               = " << "0" << std::endl
     980                << "[152] GETM COST (FLITS * DIST)  = " << "0" << std::endl
     981                << std::endl
     982                << "[160] LOCAL INVAL RO            = " << "0" << std::endl
     983                << "[161] REMOTE INVAL RO           = " << "0" << std::endl
     984                << "[162] INVAL RO COST             = " << "0" << std::endl
    963985                << std::endl;
    964986        }
    965987
    966         if (stats) {
    967             std::cout << "----------------------------------" << std::dec << std::endl;
    968             std::cout << "---      Calculated Stats      ---" << std::dec << std::endl;
    969             std::cout << "----------------------------------" << std::dec << std::endl;
    970             std::cout
    971                 << "[300] READ TOTAL            = " << m_cpt_read_local + m_cpt_read_remote << std::endl
    972                 << "[301] READ RATE             = " << (double) (m_cpt_read_local + m_cpt_read_remote) / m_cpt_cycles << std::endl
    973                 << "[302] LOCAL READ RATE       = " << (double) m_cpt_read_local / m_cpt_cycles << std::endl
    974                 << "[303] REMOTE READ RATE      = " << (double) m_cpt_read_remote / m_cpt_cycles << std::endl
    975                 << "[304] READ MISS RATE        = " << (double) m_cpt_read_miss / (m_cpt_read_local + m_cpt_read_remote) << std::endl
    976                 << std::endl
    977                 << "[305] WRITE TOTAL           = " << m_cpt_write_local + m_cpt_write_remote << std::endl
    978                 << "[306] WRITE RATE            = " << (double) (m_cpt_write_local + m_cpt_write_remote) / m_cpt_cycles << std::endl
    979                 << "[307] LOCAL WRITE RATE      = " << (double) m_cpt_write_local / m_cpt_cycles << std::endl
    980                 << "[308] REMOTE WRITE RATE     = " << (double) m_cpt_write_remote / m_cpt_cycles << std::endl
    981                 << "[309] WRITE MISS RATE       = " << (double) m_cpt_write_miss / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    982                 << "[310] WRITE BURST TOTAL     = " << m_cpt_write_flits_local + m_cpt_write_flits_remote << std::endl
    983                 << "[311] WRITE BURST AVERAGE   = " << (double) (m_cpt_write_flits_local + m_cpt_write_flits_remote) / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    984                 << "[312] LOCAL WRITE BURST AV. = " << (double) m_cpt_write_flits_local / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    985                 << "[313] REMOTE WRITE BURST AV = " << (double) m_cpt_write_flits_remote / (m_cpt_write_local + m_cpt_write_remote) << std::endl
    986                 << std::endl
    987                 << "[314] UPDATE RATE                = " << (double) m_cpt_update / m_cpt_cycles << std::endl
    988                 << "[315] AV. UPDATE PER UP REQ      = " << (double) (m_cpt_update_local + m_cpt_update_remote) / m_cpt_update << std::endl
    989                 << "[316] AV. LOC UPDT PER UP REQ    = " << (double) m_cpt_update_local / m_cpt_update << std::endl
    990                 << "[317] AV. REMOTE UPDT PER UP REQ = " << (double) m_cpt_update_remote / m_cpt_update << std::endl
    991                 << std::endl
    992                 << "[318] INVAL MULTICAST RATE  = " << (double) m_cpt_minval / m_cpt_cycles << std::endl
    993                 << "[319] AVE. INVAL PER M_INV  = " << (double) (m_cpt_minval_local + m_cpt_minval_remote) / m_cpt_minval << std::endl
    994                 << "[320] AV. LOC INV PER M_INV = " << (double) m_cpt_minval_local / m_cpt_minval << std::endl
    995                 << "[321] AV. REM INV PER M_INV = " << (double) m_cpt_minval_remote / m_cpt_minval << std::endl
    996                 << std::endl
    997                 << "[322] INVAL BROADCAST RATE  = " << (double) m_cpt_binval / m_cpt_cycles << std::endl
    998                 << "[323] WRITE DIRTY RATE      = " << (double) m_cpt_write_dirty / m_cpt_cycles << std::endl
    999                 << std::endl
    1000                 << "[324] CLEANUP RATE          = " << (double) (m_cpt_cleanup_local + m_cpt_cleanup_remote) / m_cpt_cycles << std::endl
    1001                 << "[325] LOCAL CLEANUP RATE    = " << (double) m_cpt_cleanup_local / m_cpt_cycles << std::endl
    1002                 << "[326] REMOTE CLEANUP RATE   = " << (double) m_cpt_cleanup_remote / m_cpt_cycles << std::endl
    1003                 << "[327] LL RATE               = " << (double) (m_cpt_ll_local + m_cpt_ll_remote) / m_cpt_cycles << std::endl
    1004                 << "[328] LOCAL LL RATE         = " << (double) m_cpt_ll_local / m_cpt_cycles << std::endl
    1005                 << "[329] REMOTE LL RATE        = " << (double) m_cpt_ll_remote / m_cpt_cycles << std::endl
    1006                 << "[330] SC RATE               = " << (double) (m_cpt_sc_local + m_cpt_sc_remote) / m_cpt_cycles << std::endl
    1007                 << "[331] LOCAL SC RATE         = " << (double) m_cpt_sc_local / m_cpt_cycles << std::endl
    1008                 << "[332] REMOTE SC RATE        = " << (double) m_cpt_sc_remote / m_cpt_cycles << std::endl
    1009                 << "[333] CAS RATE              = " << (double) (m_cpt_cas_local + m_cpt_cas_remote) / m_cpt_cycles << std::endl
    1010                 << "[334] LOCAL CAS RATE        = " << (double) m_cpt_cas_local / m_cpt_cycles << std::endl
    1011                 << "[335] REMOTE CAS RATE       = " << (double) m_cpt_cas_remote / m_cpt_cycles << std::endl
    1012                 << std::endl
    1013                 << std::endl;
    1014         }
    1015988    }
    1016989
    … …  
    11981171            m_cpt_read_remote         = 0;
    11991172            m_cpt_read_cost           = 0;
     1173
    12001174            m_cpt_write_local         = 0;
    12011175            m_cpt_write_remote        = 0;
    … …  
    12041178            m_cpt_write_ncc_miss      = 0;
    12051179            m_cpt_write_cost          = 0;
     1180
    12061181            m_cpt_ll_local            = 0;
    12071182            m_cpt_ll_remote           = 0;
    12081183            m_cpt_ll_cost             = 0;
     1184
    12091185            m_cpt_sc_local            = 0;
    12101186            m_cpt_sc_remote           = 0;
    12111187            m_cpt_sc_cost             = 0;
     1188
    12121189            m_cpt_cas_local           = 0;
    12131190            m_cpt_cas_remote          = 0;
    12141191            m_cpt_cas_cost            = 0;
     1192
    12151193            m_cpt_update              = 0;
    12161194            m_cpt_update_local        = 0;
    12171195            m_cpt_update_remote       = 0;
    12181196            m_cpt_update_cost         = 0;
     1197
    12191198            m_cpt_minval              = 0;
    12201199            m_cpt_minval_local        = 0;
    12211200            m_cpt_minval_remote       = 0;
    12221201            m_cpt_minval_cost         = 0;
     1202
    12231203            m_cpt_binval              = 0;
     1204            m_cpt_write_broadcast     = 0;
     1205
    12241206            m_cpt_cleanup_local       = 0;
    12251207            m_cpt_cleanup_remote      = 0;
    … …  
    12291211            m_cpt_cleanup_data_cost   = 0;
    12301212
    1231 
    1232             m_cpt_read_miss               = 0;
    1233             m_cpt_write_miss              = 0;
    1234             m_cpt_write_dirty             = 0;
    1235             m_cpt_write_broadcast         = 0;
    1236             m_cpt_trt_rb                  = 0;
    1237             m_cpt_trt_full                = 0;
    1238             m_cpt_get                     = 0;
    1239             m_cpt_put                     = 0;
     1213            m_cpt_read_miss           = 0;
     1214            m_cpt_write_miss          = 0;
     1215            m_cpt_write_dirty         = 0;
     1216
     1217            m_cpt_trt_rb              = 0;
     1218            m_cpt_trt_full            = 0;
     1219            m_cpt_get                 = 0;
     1220            m_cpt_put                 = 0;
     1221
     1222            m_cpt_ncc_to_cc_read          = 0;
     1223            m_cpt_ncc_to_cc_write         = 0;
     1224
     1225            m_cpt_heap_min_slot_available = m_heap_size;
     1226            m_cpt_heap_slot_available     = m_heap_size;
     1227
    12401228            m_cpt_dir_unused              = 0;
    12411229            m_cpt_upt_unused              = 0;
    … …  
    12431231            m_cpt_heap_unused             = 0;
    12441232            m_cpt_trt_unused              = 0;
    1245             m_cpt_read_fsm_n_dir_lock     = 0;
    1246             m_cpt_read_fsm_dir_lock       = 0;
    1247             m_cpt_read_fsm_dir_used       = 0;
    1248             m_cpt_read_fsm_trt_lock       = 0;
    1249             m_cpt_read_fsm_heap_lock      = 0;
    1250             m_cpt_write_fsm_dir_lock      = 0;
    1251             m_cpt_write_fsm_n_dir_lock    = 0;
    1252             m_cpt_write_fsm_upt_lock      = 0;
    1253             m_cpt_write_fsm_heap_lock     = 0;
    1254             m_cpt_write_fsm_dir_used      = 0;
    1255             m_cpt_write_fsm_trt_lock      = 0;
    1256             m_cpt_cas_fsm_n_dir_lock      = 0;
    1257             m_cpt_cas_fsm_dir_lock        = 0;
    1258             m_cpt_cas_fsm_upt_lock        = 0;
    1259             m_cpt_cas_fsm_heap_lock       = 0;
    1260             m_cpt_cas_fsm_trt_lock        = 0;
    1261             m_cpt_cas_fsm_dir_used        = 0;
    1262             m_cpt_xram_rsp_fsm_n_dir_lock = 0;
    1263             m_cpt_xram_rsp_fsm_dir_lock   = 0;
    1264             m_cpt_xram_rsp_fsm_trt_lock   = 0;
    1265             m_cpt_xram_rsp_fsm_upt_lock   = 0;
    1266             m_cpt_xram_rsp_fsm_heap_lock  = 0;
    1267             m_cpt_xram_rsp_fsm_dir_used   = 0;
    1268             m_cpt_cleanup_fsm_dir_lock    = 0;
    1269             m_cpt_cleanup_fsm_n_dir_lock  = 0;
    1270             m_cpt_cleanup_fsm_heap_lock   = 0;
    1271             m_cpt_cleanup_fsm_ivt_lock    = 0;
    1272             m_cpt_cleanup_fsm_dir_used    = 0;
    1273             m_cpt_ixr_fsm_trt_lock        = 0;
    1274             m_cpt_multi_ack_fsm_upt_lock  = 0;
    1275             m_cpt_read_data_unc           = 0;   
    1276             m_cpt_read_data_miss_CC       = 0;   
    1277             m_cpt_read_ins_unc            = 0;       
    1278             m_cpt_read_ins_miss           = 0;     
    1279             m_cpt_read_ll_CC              = 0;       
    1280             m_cpt_read_data_miss_NCC      = 0;       
    1281             m_cpt_read_ll_NCC             = 0;   
    1282             m_cpt_ncc_to_cc_read          = 0;     
    1283             m_cpt_ncc_to_cc_write         = 0;       
    1284 
    1285             m_cpt_heap_min_slot_available = m_heap_size;
    1286             m_cpt_heap_slot_available     = m_heap_size;
     1233
     1234            // Unused
     1235            m_cpt_read_data_unc           = 0;
     1236            m_cpt_read_data_miss_CC       = 0;
     1237            m_cpt_read_ins_unc            = 0;
     1238            m_cpt_read_ins_miss           = 0;
     1239            m_cpt_read_ll_CC              = 0;
     1240            m_cpt_read_data_miss_NCC      = 0;
     1241            m_cpt_read_ll_NCC             = 0;
    12871242
    12881243            return;
    … …  
    19001855                    // <Activity counters>
    19011856                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) {
    1902                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_ll_local++;
    1903                         else                                      m_cpt_ll_remote++;
    1904                         m_cpt_ll_cost += req_distance(p_vci_tgt.srcid.read()); // LL on a single word
     1857                        if (is_local_req(p_vci_tgt.srcid.read()))
     1858                        {
     1859                            m_cpt_ll_local++;
     1860                        }
     1861                        else
     1862                        {
     1863                            m_cpt_ll_remote++;
     1864                        }
     1865                        // (1 (CMD) + 2 (RSP)) VCI flits for LL => 2 + 3 dspin flits
     1866                        m_cpt_ll_cost += 5 * req_distance(p_vci_tgt.srcid.read()); // LL on a single word
    19051867                    }
    19061868                    else {
    1907                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_read_local++;
    1908                         else                                      m_cpt_read_remote++;
    1909                         m_cpt_read_cost += m_words * req_distance(p_vci_tgt.srcid.read());
     1869                        if (is_local_req(p_vci_tgt.srcid.read()))
     1870                        {
     1871                            m_cpt_read_local++;
     1872                        }
     1873                        else
     1874                        {
     1875                            m_cpt_read_remote++;
     1876                        }
     1877                        // (1 (CMD) + m_words (RSP)) flits VCI => 2 + m_words + 1 flits dspin
     1878                        m_cpt_read_cost += (3 + m_words) * req_distance(p_vci_tgt.srcid.read());
    19101879                    }
    19111880                    // </Activity counters>
    … …  
    19181887                if(p_vci_tgt.cmdval and m_cmd_write_addr_fifo.wok())
    19191888                {
    1920 
     1889                    uint32_t plen = p_vci_tgt.plen.read();
    19211890#if DEBUG_MEMC_TGT_CMD
    19221891                    if(m_debug)
    … …  
    19331902                    // <Activity counters>
    19341903                    if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
    1935                         m_cpt_sc_cost += req_distance(p_vci_tgt.srcid.read());
     1904                        // (2 (CMD) + 1 (RSP)) flits VCI => 4 + (1 (success) || 2 (failure)) flits dspin
     1905                        m_cpt_sc_cost += 5 * req_distance(p_vci_tgt.srcid.read());
    19361906                    }
    19371907                    else {
    1938                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_flits_local++;
    1939                         else                                      m_cpt_write_flits_remote++;
    1940                         m_cpt_write_cost += req_distance(p_vci_tgt.srcid.read());
     1908                        if (is_local_req(p_vci_tgt.srcid.read()))
     1909                        {
     1910                            m_cpt_write_flits_local++;
     1911                        }
     1912                        else
     1913                        {
     1914                            m_cpt_write_flits_remote++;
     1915                        }
     1916                        // (burst_size (CMD) + 1 (RSP) flits VCI => 2 + burst_size + 1 flits dspin
     1917                        m_cpt_write_cost += (3 + (plen >> 2)) * req_distance(p_vci_tgt.srcid.read());
    19411918                    }
    19421919                    // </Activity counters>
    … …  
    19451922                        // <Activity counters>
    19461923                        if (p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP) {
    1947                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_sc_local++;
    1948                             else                                      m_cpt_sc_remote++;
    1949 
     1924                            if (is_local_req(p_vci_tgt.srcid.read()))
     1925                            {
     1926                                m_cpt_sc_local++;
     1927                            }
     1928                            else
     1929                            {
     1930                                m_cpt_sc_remote++;
     1931                            }
    19501932                        }
    19511933                        else {
    1952                             if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_write_local++;
    1953                             else                                      m_cpt_write_remote++;
     1934                            if (is_local_req(p_vci_tgt.srcid.read()))
     1935                            {
     1936                                m_cpt_write_local++;
     1937                            }
     1938                            else
     1939                            {
     1940                                m_cpt_write_remote++;
     1941                            }
    19541942                        }
    19551943                        // </Activity counters>
    … …  
    19851973                    if (p_vci_tgt.eop) {
    19861974                        // <Activity counters>
    1987                         if (is_local_req(p_vci_tgt.srcid.read())) m_cpt_cas_local++;
    1988                         else                                      m_cpt_cas_remote++;
    1989                         m_cpt_cas_cost += req_distance(p_vci_tgt.srcid.read());
     1975                        if (is_local_req(p_vci_tgt.srcid.read()))
     1976                        {
     1977                            m_cpt_cas_local++;
     1978                        }
     1979                        else
     1980                        {
     1981                            m_cpt_cas_remote++;
     1982                        }
     1983                        // (2 (CMD) + 1 (RSP)) flits VCI => 4 + (1 (success) || 2 (failure)) flits dspin
     1984                        m_cpt_cas_cost += 5 * req_distance(p_vci_tgt.srcid.read());
    19901985                        // </Activity counters>
    19911986                        r_tgt_cmd_fsm = TGT_CMD_IDLE;
    … …  
    20702065            case MULTI_ACK_UPT_LOCK:
    20712066                {
    2072                     m_cpt_multi_ack_fsm_upt_lock++;
    20732067                    // get lock to the UPDATE table
    20742068                    if(r_alloc_upt_fsm.read() != ALLOC_UPT_MULTI_ACK)  break;
    … …  
    21022096                            << " entry = "       << r_multi_ack_upt_index.read()
    21032097                            << " / rsp_count = " << std::dec << count << std::endl;
    2104                     m_cpt_multi_ack_fsm_n_upt_lock++;
    21052098#endif
    21062099                    break;
    … …  
    27622755                    {
    27632756                        r_read_fsm = READ_DIR_LOCK;
    2764                         m_cpt_read_fsm_n_dir_lock++;
    27652757                    }
    27662758
    … …  
    27692761                        std::cout << "  <MEMC " << name() << " READ_DIR_REQ> Requesting DIR lock " << std::endl;
    27702762#endif
    2771 
    2772                     m_cpt_read_fsm_dir_lock++;
    2773 
    27742763                    break;
    27752764                }
    … …  
    30163005                    {
    30173006                        r_read_fsm = READ_HEAP_LOCK;
    3018                         m_cpt_read_fsm_n_heap_lock++;
    30193007                    }
    30203008
    … …  
    30243012                            << " Requesting HEAP lock " << std::endl;
    30253013#endif
    3026 
    3027                     m_cpt_read_fsm_heap_lock++;
    3028 
    30293014                    break;
    30303015                }
    … …  
    32973282                                << " / hit_write = " << hit_write
    32983283                                << " / full = " << !wok << std::endl;
    3299                         m_cpt_read_fsm_n_trt_lock++;
    3300 #endif
    3301                     }
    3302 
    3303                     m_cpt_read_fsm_trt_lock++;
    3304 
     3284#endif
     3285                    }
    33053286                    break;
    33063287                }
    … …  
    38213802                        if(wok) r_write_fsm = WRITE_UPT_HEAP_LOCK;
    38223803                        else    r_write_fsm = WRITE_WAIT;
    3823                         m_cpt_write_fsm_n_upt_lock++;
    3824                     }
    3825 
    3826                     m_cpt_write_fsm_upt_lock++;
    3827 
     3804                    }
    38283805                    break;
    38293806                }
    … …  
    38413818#endif
    38423819                        r_write_fsm = WRITE_UPT_REQ;
    3843                         m_cpt_write_fsm_n_heap_lock++;
    3844                     }
    3845 
    3846                     m_cpt_write_fsm_heap_lock++;
    3847 
     3820                    }
    38483821                    break;
    38493822                }
    … …  
    43414314                            << " / index = " << wok_index << std::endl;
    43424315#endif
    4343 
    4344                     m_cpt_write_fsm_trt_lock++;
    4345 
    43464316                    break;
    43474317                }
    … …  
    43854355                        if(wok) r_write_fsm = WRITE_BC_DIR_INVAL;
    43864356                        else    r_write_fsm = WRITE_WAIT;
    4387                         m_cpt_write_fsm_n_upt_lock++;
    4388                     }
    4389 
    4390                     m_cpt_write_fsm_upt_lock++;
    4391 
     4357                    }
    43924358                    break;
    43934359                }
    … …  
    50004966                                << " / data = " << std::hex << data << std::endl;
    50014967#endif
    5002                         m_cpt_ixr_fsm_n_trt_lock++;
    5003                     }
    5004                     m_cpt_ixr_fsm_trt_lock++;
     4968                    }
    50054969                    break;
    50064970                }
    … …  
    50745038                                << " Get access to DIR and TRT" << std::endl;
    50755039#endif
    5076                         m_cpt_xram_rsp_fsm_n_dir_lock++;
    5077                         m_cpt_xram_rsp_fsm_n_trt_lock++;
    5078                     }
    5079                     m_cpt_xram_rsp_fsm_dir_lock++;
    5080                     m_cpt_xram_rsp_fsm_trt_lock++;
     5040                    }
    50815041                    break;
    50825042                }
    … …  
    53655325                        else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
    53665326                        else                                     r_xram_rsp_fsm = XRAM_RSP_WRITE_DIRTY;
    5367                         m_cpt_xram_rsp_fsm_n_trt_lock++;
    5368                     }
    5369 
    5370                     m_cpt_xram_rsp_fsm_trt_lock++;
    5371 
     5327                    }
    53725328                    break;
    53735329                }
    … …  
    54775433                    {
    54785434                        r_xram_rsp_fsm = XRAM_RSP_HEAP_ERASE;
    5479                         m_cpt_xram_rsp_fsm_n_heap_lock++;
    54805435                    }
    54815436
    … …  
    54855440                            << " Requesting HEAP lock" << std::endl;
    54865441#endif
    5487 
    5488                     m_cpt_xram_rsp_fsm_heap_lock++;
    5489 
    54905442                    break;
    54915443                }
    … …  
    57435695                            m_cpt_cleanup_data_remote++;
    57445696                        }
    5745                         m_cpt_cleanup_cost += m_words * req_distance(srcid);
    5746                         m_cpt_cleanup_data_cost += m_words * req_distance(srcid);
     5697                        // 2 + m_words flits for cleanup with data
     5698                        m_cpt_cleanup_cost += (m_words + 2) * req_distance(srcid);
     5699                        m_cpt_cleanup_data_cost += (m_words + 2)  * req_distance(srcid);
    57475700                        // </Activity Counters>
    57485701                    }
    … …  
    57575710                            m_cpt_cleanup_remote++;
    57585711                        }
    5759                         m_cpt_cleanup_cost += req_distance(srcid);
     5712                        // 2 flits for cleanup without data
     5713                        m_cpt_cleanup_cost += 2 * req_distance(srcid);
    57605714                        // </Activity Counters>
    57615715                    }
    … …  
    58135767            case CLEANUP_DIR_REQ:   // Get the lock to the directory
    58145768                {
    5815                     m_cpt_cleanup_fsm_dir_lock++;
    58165769                    if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP) break;
    58175770
    … …  
    58225775                        std::cout << "  <MEMC " << name() << " CLEANUP_DIR_REQ> Requesting DIR lock" << std::endl;
    58235776#endif
    5824 
    5825                     m_cpt_cleanup_fsm_n_dir_lock++;
    5826 
    58275777                    break;
    58285778                }
    … …  
    61656115                    }
    61666116#endif
    6167                     m_cpt_cleanup_fsm_n_heap_lock++;
    61686117                    break;
    61696118                }
    … …  
    64076356                // invalidate transaction matching the cleanup
    64086357                {
    6409                     m_cpt_cleanup_fsm_ivt_lock++;
    64106358                    if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    64116359
    … …  
    64276375                                << std::endl;
    64286376#endif
    6429                         m_cpt_cleanup_fsm_n_upt_lock++;
    64306377                    }
    64316378                    else
    … …  
    67236670                    {
    67246671                        r_cas_fsm = CAS_DIR_LOCK;
    6725                         m_cpt_cas_fsm_n_dir_lock++;
    67266672                    }
    67276673
    … …  
    67346680                    }
    67356681#endif
    6736 
    6737                     m_cpt_cas_fsm_dir_lock++;
    6738 
    67396682                    break;
    67406683                }
    … …  
    69676910                                << " / count = " << nb_copies << std::endl;
    69686911#endif
    6969                         m_cpt_cas_fsm_n_upt_lock++;
    6970                     }
    6971 
    6972                     m_cpt_cas_fsm_upt_lock++;
    6973 
     6912                    }
    69746913                    break;
    69756914                }
    … …  
    70026941#endif
    70036942                        r_cas_fsm = CAS_UPT_REQ;
    7004                         m_cpt_cas_fsm_n_heap_lock++;
    7005                     }
    7006 
    7007                     m_cpt_cas_fsm_heap_lock++;
    7008 
     6943                    }
    70096944                    break;
    70106945                }
    … …  
    71187053                        {
    71197054                            r_cas_fsm       = CAS_WAIT;
    7120                             m_cpt_cas_fsm_n_trt_lock++;
    71217055                        }
    71227056
    … …  
    71277061#endif
    71287062                    }
    7129                     m_cpt_cas_fsm_trt_lock++;
    7130 
    71317063                    break;
    71327064                }
    … …  
    71847116                            r_cas_fsm = CAS_WAIT;
    71857117                        }
    7186                         m_cpt_cas_fsm_n_upt_lock++;
    7187                     }
    7188 
    7189                     m_cpt_cas_fsm_upt_lock++;
    7190 
     7118                    }
    71917119                    break;
    71927120                }
    … …  
    73667294                            r_cas_fsm       = CAS_MISS_TRT_SET;
    73677295                        }
    7368                         m_cpt_cas_fsm_n_trt_lock++;
    7369                     }
    7370 
    7371                     m_cpt_cas_fsm_trt_lock++;
    7372 
     7296                    }
    73737297                    break;
    73747298                }
    … …  
    77937717                    {
    77947718                        if(not p_dspin_m2p.read) break;
     7719
    77957720                        // <Activity Counters>
    77967721                        if (is_local_req(m_config_to_cc_send_srcid_fifo.read()))
    … …  
    78027727                            m_cpt_minval_remote++;
    78037728                        }
    7804                         m_cpt_minval_cost += req_distance(m_config_to_cc_send_srcid_fifo.read());
     7729                        // 2 flits for multi inval
     7730                        m_cpt_minval_cost += 2 * req_distance(m_config_to_cc_send_srcid_fifo.read());
    78057731                        // </Activity Counters>
    78067732                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    … …  
    78697795                            m_cpt_minval_remote++;
    78707796                        }
    7871                         m_cpt_minval_cost += req_distance(m_xram_rsp_to_cc_send_srcid_fifo.read());
     7797                        // 2 flits for multi inval
     7798                        m_cpt_minval_cost += 2 * req_distance(m_xram_rsp_to_cc_send_srcid_fifo.read());
    78727799                        // </Activity Counters>
    78737800                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    … …  
    80227949                            m_cpt_update_remote++;
    80237950                        }
    8024                         m_cpt_update_cost += req_distance(m_write_to_cc_send_srcid_fifo.read());
     7951                        // 2 flits for multi inval
     7952                        m_cpt_update_cost += 2 * req_distance(m_write_to_cc_send_srcid_fifo.read());
    80257953                        // </Activity Counters>
    80267954
    … …  
    81118039                            m_cpt_update_remote++;
    81128040                        }
    8113                         m_cpt_update_cost += req_distance(m_cas_to_cc_send_srcid_fifo.read());
     8041                        // 2 flits for multi inval
     8042                        m_cpt_update_cost += 2 * req_distance(m_cas_to_cc_send_srcid_fifo.read());
    81148043                        // </Activity Counters>
    81158044                        r_cc_send_fsm = CC_SEND_CAS_UPDT_NLINE;
    … …  
    91269055                        m_cpt_dir_unused++;
    91279056                }
    9128                 else
    9129                     m_cpt_read_fsm_dir_used++;
    91309057                break;
    91319058
    … …  
    91689095                        m_cpt_dir_unused++;
    91699096                }
    9170                 else
    9171                     m_cpt_write_fsm_dir_used++;
    91729097                break;
    91739098
    … …  
    92099134                        m_cpt_dir_unused++;
    92109135                }
    9211                 else
    9212                     m_cpt_cas_fsm_dir_used++;
    92139136                break;
    92149137
    … …  
    92399162                        m_cpt_dir_unused++;
    92409163                }
    9241                 else
    9242                     m_cpt_cleanup_fsm_dir_used++;
    92439164                break;
    92449165
    … …  
    92679188                        m_cpt_dir_unused++;
    92689189                }
    9269                 else
    9270                     m_cpt_xram_rsp_fsm_dir_used++;
    92719190                break;
    92729191
    … …  
    93219240                        m_cpt_trt_unused++;
    93229241                }
    9323                 else
    9324                     m_cpt_read_fsm_trt_used++;
    93259242                break;
    93269243
    … …  
    93639280                        m_cpt_trt_unused++;
    93649281                }
    9365                 else
    9366                     m_cpt_write_fsm_trt_used++;
    93679282                break;
    93689283
    … …  
    94059320                        m_cpt_trt_unused++;
    94069321                }
    9407                 else
    9408                     m_cpt_cas_fsm_trt_used++;
    94099322                break;
    94109323                ///////////////////////
    … …  
    94849397                        m_cpt_trt_unused++;
    94859398                }
    9486                 else
    9487                     m_cpt_xram_rsp_fsm_trt_used++;
    94889399                break;
    94899400
    … …  
    95259436                        m_cpt_trt_unused++;
    95269437                }
    9527                 else
    9528                     m_cpt_ixr_fsm_trt_used++;
    95299438                break;
    95309439
    … …  
    96549563                        m_cpt_heap_unused++;
    96559564                }
    9656                 else
    9657                     m_cpt_read_fsm_heap_used++;
    96589565                break;
    96599566
    … …  
    96829589                        m_cpt_heap_unused++;
    96839590                }
    9684                 else
    9685                     m_cpt_write_fsm_heap_used++;
    96869591                break;
    96879592
    … …  
    97109615                        m_cpt_heap_unused++;
    97119616                }
    9712                 else
    9713                     m_cpt_cas_fsm_heap_used++;
    97149617                break;
    97159618
    … …  
    97399642                        m_cpt_heap_unused++;
    97409643                }
    9741                 else
    9742                     m_cpt_cleanup_fsm_heap_used++;
    97439644                break;
    97449645
    … …  
    97899690                        m_cpt_heap_unused++;
    97909691                }
    9791                 else
    9792                     m_cpt_xram_rsp_fsm_heap_used++;
    97939692                break;
    97949693
Note: See TracChangeset for help on using the changeset viewer.