Ignore:
Timestamp:
Nov 12, 2010, 12:21:16 PM (14 years ago)
Author:
alain
Message:

Introducing a print_trace() method

Location:
trunk/modules/vci_mem_cache_v4/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/vci_mem_cache_v4/caba/source/include/vci_mem_cache_v4.h

    r82 r116  
    5858#include "update_tab_v4.h"
    5959
    60 #define TRANSACTION_TAB_LINES 4     // Number of lines in the transaction tab
    61 #define UPDATE_TAB_LINES 4          // Number of lines in the update tab
    62 #define BROADCAST_ADDR 0x0000000003 // Address to send the broadcast invalidate
     60#define TRANSACTION_TAB_LINES   4               // Number of lines in the transaction tab
     61#define UPDATE_TAB_LINES        4               // Number of lines in the update tab
    6362
    6463namespace soclib {  namespace caba {
    … …  
    328327      void print_stats();
    329328
     329      void print_trace();
     330
    330331      private:
    331332
    332333      // Component attributes
    333       const size_t              m_initiators;           // Number of initiators
    334       const size_t              m_heap_size;            // Size of the heap
    335       const size_t              m_ways;                 // Number of ways in a set
    336       const size_t              m_sets;                 // Number of cache sets
    337       const size_t              m_words;                        // Number of words in a line
    338       const size_t              m_srcid_ixr;                // Srcid for requests to XRAM
    339       const size_t              m_srcid_ini;                // Srcid for requests to processors
    340       std::list<soclib::common::Segment>  m_seglist;    // memory cached into the cache
    341       std::list<soclib::common::Segment>  m_cseglist;   // coherence segment for the cache
     334      const size_t                      m_initiators;           // Number of initiators
     335      const size_t                      m_heap_size;            // Size of the heap
     336      const size_t                      m_ways;                 // Number of ways in a set
     337      const size_t                      m_sets;                 // Number of cache sets
     338      const size_t                      m_words;                // Number of words in a line
     339      const size_t                      m_srcid_ixr;            // Srcid for requests to XRAM
     340      const size_t                      m_srcid_ini;            // Srcid for requests to processors
     341      std::list<soclib::common::Segment>  m_seglist;            // memory cached into the cache
     342      std::list<soclib::common::Segment>  m_cseglist;           // coherence segment for the cache
    342343      vci_addr_t                        *m_coherence_table;     // address(srcid)
    343       TransactionTab                    m_transaction_tab;          // xram transaction table
    344       UpdateTab                 m_update_tab;               // pending update & invalidate
    345       CacheDirectory                    m_cache_directory;          // data cache directory
    346       HeapDirectory             m_heap_directory;       // heap directory
     344      TransactionTab                    m_transaction_tab;      // xram transaction table
     345      UpdateTab                         m_update_tab;           // pending update & invalidate
     346      CacheDirectory                    m_cache_directory;      // data cache directory
     347      HeapDirectory                     m_heap_directory;       // heap directory
    347348
    348349      data_t                           ***m_cache_data;         // data array[set][way][word]
    … …  
    355356
    356357      // broadcast address
    357       vci_addr_t broadcast_addr;
     358      vci_addr_t                        m_broadcast_address;
    358359
    359360      //////////////////////////////////////////////////

  • trunk/modules/vci_mem_cache_v4/caba/source/src/vci_mem_cache_v4.cpp

    r83 r116  
    3838namespace soclib { namespace caba {
    3939
    40 #ifdef DEBUG_VCI_MEM_CACHE
    4140  const char *tgt_cmd_fsm_str[] = {
    42     "TGT_CMD_IDLE",
    43     "TGT_CMD_READ",
     41    "TGT_CMD_IDLE    ",
     42    "TGT_CMD_READ    ",
    4443    "TGT_CMD_READ_EOP",
    45     "TGT_CMD_WRITE",
    46     "TGT_CMD_ATOMIC",
     44    "TGT_CMD_WRITE   ",
     45    "TGT_CMD_ATOMIC  ",
    4746  };
    4847  const char *tgt_rsp_fsm_str[] = {
    49     "TGT_RSP_READ_IDLE",
    50     "TGT_RSP_WRITE_IDLE",
    51     "TGT_RSP_LLSC_IDLE",
    52     "TGT_RSP_XRAM_IDLE",
    53     "TGT_RSP_INIT_IDLE",
     48    "TGT_RSP_READ_IDLE   ",
     49    "TGT_RSP_WRITE_IDLE  ",
     50    "TGT_RSP_LLSC_IDLE   ",
     51    "TGT_RSP_XRAM_IDLE   ",
     52    "TGT_RSP_INIT_IDLE   ",
    5453    "TGT_RSP_CLEANUP_IDLE",
    55     "TGT_RSP_READ",
    56     "TGT_RSP_WRITE",
    57     "TGT_RSP_LLSC",
    58     "TGT_RSP_XRAM",
    59     "TGT_RSP_INIT",
    60     "TGT_RSP_CLEANUP",
     54    "TGT_RSP_READ        ",
     55    "TGT_RSP_WRITE       ",
     56    "TGT_RSP_LLSC        ",
     57    "TGT_RSP_XRAM        ",
     58    "TGT_RSP_INIT        ",
     59    "TGT_RSP_CLEANUP     ",
    6160  };
    6261  const char *init_cmd_fsm_str[] = {
    63     "INIT_CMD_INVAL_IDLE",
    64     "INIT_CMD_INVAL_NLINE",
    65     "INIT_CMD_XRAM_BRDCAST",
    66     "INIT_CMD_UPDT_IDLE",
    67     "INIT_CMD_WRITE_BRDCAST",
    68     "INIT_CMD_UPDT_NLINE",
    69     "INIT_CMD_UPDT_INDEX",
    70     "INIT_CMD_UPDT_DATA",
    71     "INIT_CMD_SC_UPDT_IDLE",
    72     "INIT_CMD_SC_BRDCAST",
    73     "INIT_CMD_SC_UPDT_NLINE",
    74     "INIT_CMD_SC_UPDT_INDEX",
    75     "INIT_CMD_SC_UPDT_DATA",
     62    "INIT_CMD_INVAL_IDLE       ",
     63    "INIT_CMD_INVAL_NLINE      ",
     64    "INIT_CMD_XRAM_BRDCAST     ",
     65    "INIT_CMD_UPDT_IDLE        ",
     66    "INIT_CMD_WRITE_BRDCAST    ",
     67    "INIT_CMD_UPDT_NLINE       ",
     68    "INIT_CMD_UPDT_INDEX       ",
     69    "INIT_CMD_UPDT_DATA        ",
     70    "INIT_CMD_SC_UPDT_IDLE     ",
     71    "INIT_CMD_SC_BRDCAST       ",
     72    "INIT_CMD_SC_UPDT_NLINE    ",
     73    "INIT_CMD_SC_UPDT_INDEX    ",
     74    "INIT_CMD_SC_UPDT_DATA     ",
    7675    "INIT_CMD_SC_UPDT_DATA_HIGH",
    7776  };
    7877  const char *init_rsp_fsm_str[] = {
    79     "INIT_RSP_IDLE",
    80     "INIT_RSP_UPT_LOCK",
     78    "INIT_RSP_IDLE     ",
     79    "INIT_RSP_UPT_LOCK ",
    8180    "INIT_RSP_UPT_CLEAR",
    82     "INIT_RSP_END",
     81    "INIT_RSP_END      ",
    8382  };
    8483  const char *read_fsm_str[] = {
    85     "READ_IDLE",
    86     "READ_DIR_LOCK",
    87     "READ_DIR_HIT",
    88     "READ_HEAP_LOCK",
     84    "READ_IDLE      ",
     85    "READ_DIR_LOCK  ",
     86    "READ_DIR_HIT   ",
     87    "READ_HEAP_LOCK ",
    8988    "READ_HEAP_WRITE",
    9089    "READ_HEAP_ERASE",
    91     "READ_HEAP_LAST",
    92     "READ_RSP",
    93     "READ_TRT_LOCK",
    94     "READ_TRT_SET",
    95     "READ_XRAM_REQ",
     90    "READ_HEAP_LAST ",
     91    "READ_RSP       ",
     92    "READ_TRT_LOCK  ",
     93    "READ_TRT_SET   ",
     94    "READ_XRAM_REQ  ",
    9695  };
    9796  const char *write_fsm_str[] = {
    98     "WRITE_IDLE",
    99     "WRITE_NEXT",
    100     "WRITE_DIR_LOCK",
    101     "WRITE_DIR_HIT_READ",
    102     "WRITE_DIR_HIT",
    103     "WRITE_UPT_LOCK",
    104     "WRITE_HEAP_LOCK",
    105     "WRITE_UPT_REQ",
    106     "WRITE_UPDATE",
    107     "WRITE_UPT_DEC",
    108     "WRITE_RSP",
    109     "WRITE_TRT_LOCK",
    110     "WRITE_TRT_DATA",
    111     "WRITE_TRT_SET",
    112     "WRITE_WAIT",
    113     "WRITE_XRAM_REQ",
     97    "WRITE_IDLE          ",
     98    "WRITE_NEXT          ",
     99    "WRITE_DIR_LOCK      ",
     100    "WRITE_DIR_HIT_READ  ",
     101    "WRITE_DIR_HIT       ",
     102    "WRITE_UPT_LOCK      ",
     103    "WRITE_HEAP_LOCK     ",
     104    "WRITE_UPT_REQ       ",
     105    "WRITE_UPDATE        ",
     106    "WRITE_UPT_DEC       ",
     107    "WRITE_RSP           ",
     108    "WRITE_TRT_LOCK      ",
     109    "WRITE_TRT_DATA      ",
     110    "WRITE_TRT_SET       ",
     111    "WRITE_WAIT          ",
     112    "WRITE_XRAM_REQ      ",
    114113    "WRITE_TRT_WRITE_LOCK",
    115     "WRITE_INVAL_LOCK",
    116     "WRITE_DIR_INVAL",
    117     "WRITE_INVAL",
    118     "WRITE_XRAM_SEND",
     114    "WRITE_INVAL_LOCK    ",
     115    "WRITE_DIR_INVAL     ",
     116    "WRITE_INVAL         ",
     117    "WRITE_XRAM_SEND     ",
    119118  };
    120119  const char *ixr_rsp_fsm_str[] = {
    121     "IXR_RSP_IDLE",
    122     "IXR_RSP_ACK",
     120    "IXR_RSP_IDLE     ",
     121    "IXR_RSP_ACK      ",
    123122    "IXR_RSP_TRT_ERASE",
    124     "IXR_RSP_TRT_READ",
     123    "IXR_RSP_TRT_READ ",
    125124  };
    126125  const char *xram_rsp_fsm_str[] = {
    127     "XRAM_RSP_IDLE",
    128     "XRAM_RSP_TRT_COPY",
    129     "XRAM_RSP_TRT_DIRTY",
    130     "XRAM_RSP_DIR_LOCK",
    131     "XRAM_RSP_DIR_UPDT",
    132     "XRAM_RSP_DIR_RSP",
    133     "XRAM_RSP_INVAL_LOCK",
    134     "XRAM_RSP_INVAL_WAIT",
    135     "XRAM_RSP_INVAL",
     126    "XRAM_RSP_IDLE       ",
     127    "XRAM_RSP_TRT_COPY   ",
     128    "XRAM_RSP_TRT_DIRTY  ",
     129    "XRAM_RSP_DIR_LOCK   ",
     130    "XRAM_RSP_DIR_UPDT   ",
     131    "XRAM_RSP_DIR_RSP    ",
     132    "XRAM_RSP_INVAL_LOCK ",
     133    "XRAM_RSP_INVAL_WAIT ",
     134    "XRAM_RSP_INVAL      ",
    136135    "XRAM_RSP_WRITE_DIRTY",
    137     "XRAM_RSP_HEAP_ERASE",
    138     "XRAM_RSP_HEAP_LAST",
     136    "XRAM_RSP_HEAP_ERASE ",
     137    "XRAM_RSP_HEAP_LAST  ",
    139138  };
    140139  const char *ixr_cmd_fsm_str[] = {
    141     "IXR_CMD_READ_IDLE",
    142     "IXR_CMD_WRITE_IDLE",
    143     "IXR_CMD_LLSC_IDLE",
    144     "IXR_CMD_XRAM_IDLE",
    145     "IXR_CMD_READ_NLINE",
    146     "IXR_CMD_WRITE_NLINE",
    147     "IXR_CMD_LLSC_NLINE",
    148     "IXR_CMD_XRAM_DATA",
     140    "IXR_CMD_READ_IDLE   ",
     141    "IXR_CMD_WRITE_IDLE  ",
     142    "IXR_CMD_LLSC_IDLE   ",
     143    "IXR_CMD_XRAM_IDLE   ",
     144    "IXR_CMD_READ_NLINE  ",
     145    "IXR_CMD_WRITE_NLINE ",
     146    "IXR_CMD_LLSC_NLINE  ",
     147    "IXR_CMD_XRAM_DATA   ",
    149148  };
    150149  const char *llsc_fsm_str[] = {
    151     "LLSC_IDLE",
    152     "SC_DIR_LOCK",
    153     "SC_DIR_HIT_READ",
     150    "LLSC_IDLE       ",
     151    "SC_DIR_LOCK     ",
     152    "SC_DIR_HIT_READ ",
    154153    "SC_DIR_HIT_WRITE",
    155     "SC_UPT_LOCK",
    156     "SC_WAIT",
    157     "SC_HEAP_LOCK",
    158     "SC_UPT_REQ",
    159     "SC_UPDATE",
    160     "SC_TRT_LOCK",
    161     "SC_INVAL_LOCK",
    162     "SC_DIR_INVAL",
    163     "SC_INVAL",
    164     "SC_XRAM_SEND",
    165     "SC_RSP_FALSE",
    166     "SC_RSP_TRUE",
    167     "LLSC_TRT_LOCK",
    168     "LLSC_TRT_SET",
    169     "LLSC_XRAM_REQ",
     154    "SC_UPT_LOCK     ",
     155    "SC_WAIT         ",
     156    "SC_HEAP_LOCK    ",
     157    "SC_UPT_REQ      ",
     158    "SC_UPDATE       ",
     159    "SC_TRT_LOCK     ",
     160    "SC_INVAL_LOCK   ",
     161    "SC_DIR_INVAL    ",
     162    "SC_INVAL        ",
     163    "SC_XRAM_SEND    ",
     164    "SC_RSP_FALSE    ",
     165    "SC_RSP_TRUE     ",
     166    "LLSC_TRT_LOCK   ",
     167    "LLSC_TRT_SET    ",
     168    "LLSC_XRAM_REQ   ",
    170169  };
    171170  const char *cleanup_fsm_str[] = {
    172     "CLEANUP_IDLE",
    173     "CLEANUP_DIR_LOCK",
    174     "CLEANUP_DIR_WRITE",
    175     "CLEANUP_HEAP_LOCK",
     171    "CLEANUP_IDLE       ",
     172    "CLEANUP_DIR_LOCK   ",
     173    "CLEANUP_DIR_WRITE  ",
     174    "CLEANUP_HEAP_LOCK  ",
    176175    "CLEANUP_HEAP_SEARCH",
    177     "CLEANUP_HEAP_CLEAN",
    178     "CLEANUP_HEAP_FREE",
    179     "CLEANUP_UPT_LOCK",
    180     "CLEANUP_UPT_WRITE",
    181     "CLEANUP_WRITE_RSP",
    182     "CLEANUP_RSP",
     176    "CLEANUP_HEAP_CLEAN ",
     177    "CLEANUP_HEAP_FREE  ",
     178    "CLEANUP_UPT_LOCK   ",
     179    "CLEANUP_UPT_WRITE  ",
     180    "CLEANUP_WRITE_RSP  ",
     181    "CLEANUP_RSP        ",
    183182  };
    184183  const char *alloc_dir_fsm_str[] = {
    185     "ALLOC_DIR_READ",
    186     "ALLOC_DIR_WRITE",
    187     "ALLOC_DIR_LLSC",
    188     "ALLOC_DIR_CLEANUP",
     184    "ALLOC_DIR_READ    ",
     185    "ALLOC_DIR_WRITE   ",
     186    "ALLOC_DIR_LLSC    ",
     187    "ALLOC_DIR_CLEANUP ",
    189188    "ALLOC_DIR_XRAM_RSP",
    190189  };
    191190  const char *alloc_trt_fsm_str[] = {
    192     "ALLOC_TRT_READ",
    193     "ALLOC_TRT_WRITE",
    194     "ALLOC_TRT_LLSC",
     191    "ALLOC_TRT_READ    ",
     192    "ALLOC_TRT_WRITE   ",
     193    "ALLOC_TRT_LLSC    ",
    195194    "ALLOC_TRT_XRAM_RSP",
    196     "ALLOC_TRT_IXR_RSP",
     195    "ALLOC_TRT_IXR_RSP ",
    197196  };
    198197  const char *alloc_upt_fsm_str[] = {
    199     "ALLOC_UPT_WRITE",
     198    "ALLOC_UPT_WRITE   ",
    200199    "ALLOC_UPT_XRAM_RSP",
    201200    "ALLOC_UPT_INIT_RSP",
    202     "ALLOC_UPT_CLEANUP",
     201    "ALLOC_UPT_CLEANUP ",
    203202  };
    204203  const char *alloc_heap_fsm_str[] = {
    205     "ALLOC_HEAP_READ",
    206     "ALLOC_HEAP_WRITE",
    207     "ALLOC_HEAP_LLSC",
    208     "ALLOC_HEAP_CLEANUP",
     204    "ALLOC_HEAP_READ    ",
     205    "ALLOC_HEAP_WRITE   ",
     206    "ALLOC_HEAP_LLSC    ",
     207    "ALLOC_HEAP_CLEANUP ",
    209208    "ALLOC_HEAP_XRAM_RSP",
    210209  };
    211 
    212 #endif
    213210
    214211#define tmpl(x) template<typename vci_param> x VciMemCacheV4<vci_param>
    … …  
    322319
    323320      // Set the broadcast address with Xmin,Xmax,Ymin,Ymax set to maximum
    324       broadcast_addr = 0x3 | (0x7C1F << (vci_param::N-20));
     321      m_broadcast_address = 0x3 | (0x7C1F << (vci_param::N-20));
    325322
    326323      // Get the segments associated to the MemCache
    … …  
    396393
    397394    } // end constructor
     395
     396  //////////////////////////////////////////////////
     397  // This function prints a trace of internal states
     398  //////////////////////////////////////////////////
     399
     400  tmpl(void)::print_trace()
     401  {
     402    std::cout << "MEM_CACHE " << name() << std::endl;
     403    std::cout << " / " << tgt_cmd_fsm_str[r_tgt_cmd_fsm]
     404              << " / " << read_fsm_str[r_read_fsm]
     405              << " / " << write_fsm_str[r_write_fsm]
     406              << " / " << tgt_rsp_fsm_str[r_tgt_rsp_fsm]
     407              << " / " << init_cmd_fsm_str[r_init_cmd_fsm]
     408              << " / " << init_rsp_fsm_str[r_init_rsp_fsm] << std::endl;
     409  }
    398410
    399411  /////////////////////////////////////////
    … …  
    607619#endif
    608620
    609 
    610621    ////////////////////////////////////////////////////////////////////////////////////
    611622    //          TGT_CMD FSM
    … …  
    630641        {
    631642          if ( p_vci_tgt.cmdval ) {
    632             assert( (p_vci_tgt.srcid.read() < m_initiators)
    633                 && "VCI_MEM_CACHE error in VCI_MEM_CACHE : The received SRCID is larger than the number of initiators");
     643            assert( (p_vci_tgt.srcid.read() < m_initiators) &&
     644            "VCI_MEM_CACHE error in direct request : received SRCID is larger than the number of initiators");
    634645
    635646            bool reached = false;
    … …  
    646657            if ( !reached )
    647658            {
    648               std::cout << "VCI_MEM_CACHE Out of segment access in VCI_MEM_CACHE" << std::endl;
     659              std::cout << "VCI_MEM_CACHE Out of segment access in " << name() << std::endl;
    649660              std::cout << "Faulty address = " << std::hex << (addr_t)(p_vci_tgt.address.read()) << std::endl;
    650661              std::cout << "Faulty initiator = " << std::dec << p_vci_tgt.srcid.read() << std::endl;
    … …  
    23152326      case CLEANUP_IDLE:
    23162327        {
    2317 
    23182328          if ( p_vci_tgt_cleanup.cmdval.read() ) {
    23192329            assert( (p_vci_tgt_cleanup.srcid.read() < m_initiators) &&
    2320                 "VCI_MEM_CACHE error in VCI_MEM_CACHE in the CLEANUP network : The received SRCID is larger than the number of initiators");
     2330            "VCI_MEM_CACHE error in a cleanup request : received SRCID is larger than the number of initiators");
     2331
    23212332            bool reached = false;
    23222333            for ( size_t index = 0 ; index < ncseg && !reached ; index++ ){
    … …  
    23252336              }
    23262337            }
     2338            // only write request to a mapped address that are not broadcast are handled
    23272339            if ( (p_vci_tgt_cleanup.cmd.read() == vci_param::CMD_WRITE) &&
    2328                 (((addr_t)(p_vci_tgt_cleanup.address.read())&0x3) != 0x3) &&
    2329                 reached) {
    2330 
     2340                 ((p_vci_tgt_cleanup.address.read() & 0x3) == 0) &&
     2341                 reached)
     2342            {
    23312343              m_cpt_cleanup++;
    23322344
    … …  
    25752587          if( r_alloc_upt_fsm.read() == ALLOC_UPT_CLEANUP )
    25762588          {
    2577             size_t index;
     2589            size_t index = 0;
    25782590            bool hit_inval;
    25792591            hit_inval = m_update_tab.search_inval(r_cleanup_nline.read(),index);
    … …  
    41064118    // Command signals on the p_vci_ixr port
    41074119    ////////////////////////////////////////////////////////////
    4108 
    41094120
    41104121    p_vci_ixr.be      = 0xF;
    … …  
    43334344      case INIT_CMD_XRAM_BRDCAST:
    43344345        p_vci_ini.cmdval  = true;
    4335         p_vci_ini.address = broadcast_addr;
     4346        p_vci_ini.address = m_broadcast_address;
    43364347        p_vci_ini.wdata   = (uint32_t)r_xram_rsp_to_init_cmd_nline.read();
    43374348        p_vci_ini.be      = ((r_xram_rsp_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    43434354      case INIT_CMD_WRITE_BRDCAST:
    43444355        p_vci_ini.cmdval  = true;
    4345         p_vci_ini.address = broadcast_addr;
     4356        p_vci_ini.address = m_broadcast_address;
    43464357        p_vci_ini.wdata   = (addr_t)r_write_to_init_cmd_nline.read();
    43474358        p_vci_ini.be      = ((r_write_to_init_cmd_nline.read() >> 32) & 0x3);
    … …  
    43984409      case INIT_CMD_SC_BRDCAST:
    43994410        p_vci_ini.cmdval  = true;
    4400         p_vci_ini.address = broadcast_addr;
     4411        p_vci_ini.address = m_broadcast_address;
    44014412        p_vci_ini.wdata   = (addr_t)r_llsc_to_init_cmd_nline.read();
    44024413        p_vci_ini.be      = ((r_llsc_to_init_cmd_nline.read() >> 32) & 0x3);
Note: See TracChangeset for help on using the changeset viewer.