Changeset 449 for trunk/modules


Ignore:
Timestamp:
Jul 18, 2013, 5:54:32 PM (11 years ago)
Author:
alain
Message:

Fixing several bugs in the configuration interface.

Location:
trunk/modules/vci_mem_cache/caba/source
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

    r434 r449  
    1212// to behave in an unpredicted way.
    1313// TODO Either remove the mechanism from the mem cache or update its behaviour.
     14
    1415#define L1_MULTI_CACHE 0
    1516
    … …  
    247248    // The function returns a copy of a (valid or invalid) entry 
    248249    /////////////////////////////////////////////////////////////////////
    249     DirectoryEntry read(const addr_t &address,size_t &way)
     250    DirectoryEntry read(const addr_t &address, size_t &way)
    250251    {
    251252
    … …  
    277278    // way arguments.
    278279    /////////////////////////////////////////////////////////////////////
    279     void inval( const size_t &set, const size_t &way )
     280    void inval( const size_t &way, const size_t &set )
    280281    {
    281282        m_dir_tab[set][way].init();
    … …  
    289290    // The function returns a copy of a (valid or invalid) entry 
    290291    /////////////////////////////////////////////////////////////////////
    291     DirectoryEntry read_neutral(const addr_t &address)
     292    DirectoryEntry read_neutral( const addr_t &address,
     293                                 size_t*      ret_way,
     294                                 size_t*      ret_set )
    292295    {
    293296
    294297#define L2 soclib::common::uint32_log2
    295       const size_t set = (size_t)(address >> (L2(m_words) + 2)) & (m_sets - 1);
    296       const tag_t  tag = (tag_t)(address >> (L2(m_sets) + L2(m_words) + 2));
     298        size_t set = (size_t)(address >> (L2(m_words) + 2)) & (m_sets - 1);
     299        tag_t  tag = (tag_t)(address >> (L2(m_sets) + L2(m_words) + 2));
    297300#undef L2
    298301
    299       bool hit       = false;
    300       for ( size_t i=0 ; i<m_ways ; i++ ) {
    301         bool equal = ( m_dir_tab[set][i].tag == tag );
    302         bool valid = m_dir_tab[set][i].valid;
    303         hit = equal && valid;
    304         if ( hit ) {                   
    305           return DirectoryEntry(m_dir_tab[set][i]);
     302        for ( size_t way = 0 ; way < m_ways ; way++ )
     303        {
     304            bool equal = ( m_dir_tab[set][way].tag == tag );
     305            bool valid = m_dir_tab[set][way].valid;
     306            if ( equal and valid )
     307            {
     308                *ret_set = set;
     309                *ret_way = way;
     310                return DirectoryEntry(m_dir_tab[set][way]);
     311            }
    306312        }
    307       }
    308       return DirectoryEntry();
     313        return DirectoryEntry();
    309314    } // end read_neutral()
    310315
    … …  
    406411    void init()
    407412    {
    408       for ( size_t set=0 ; set<m_sets ; set++ ) {
    409         for ( size_t way=0 ; way<m_ways ; way++ ) {
     413      for ( size_t set=0 ; set<m_sets ; set++ )
     414      {
     415        for ( size_t way=0 ; way<m_ways ; way++ )
     416        {
    410417          m_dir_tab[set][way].init();
    411418          m_lru_tab[set][way].init();
    … …  
    688695        assert((set < m_sets ) && "Cache data error: Trying to read a wrong set" );
    689696        assert((way < m_ways ) && "Cache data error: Trying to read a wrong way" );
    690      
     697
    691698        for (uint32_t word=0; word<m_words; word++)
    692699          cache_line[word].write(m_cache_data[way][set][word]);

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

    r439 r449  
    6868    {
    6969      typedef typename vci_param_int::fast_addr_t  addr_t;
    70 
    7170      typedef typename sc_dt::sc_uint<64>          wide_data_t;
    72 
    73       typedef uint32_t data_t;
    74       typedef uint32_t tag_t;
    75       typedef uint32_t be_t;
    76       typedef uint32_t copy_t;
     71      typedef uint32_t                             data_t;
     72      typedef uint32_t                             tag_t;
     73      typedef uint32_t                             be_t;
     74      typedef uint32_t                             copy_t;
    7775
    7876      /* States of the TGT_CMD fsm */
    … …  
    390388
    391389      // debug variables (for each FSM)
    392       bool         m_debug;
    393       bool         m_debug_previous_hit;
    394       size_t       m_debug_previous_count;
     390      bool                 m_debug;
     391      bool                 m_debug_previous_valid;
     392      size_t               m_debug_previous_count;
     393      bool                 m_debug_previous_dirty;
     394      sc_signal<data_t>*   m_debug_previous_data;
     395      sc_signal<data_t>*   m_debug_data;
    395396
    396397      bool         m_monitor_ok;
    … …  
    474475      void print_stats();
    475476      void print_trace();
    476       void copies_monitor(addr_t addr);
     477      void cache_monitor(addr_t addr);
    477478      void start_monitor(addr_t addr, addr_t length);
    478479      void stop_monitor();
    … …  
    482483      void transition();
    483484      void genMoore();
    484       void check_monitor( const char *buf, addr_t addr, data_t data, bool read);
     485      void check_monitor(addr_t addr, data_t data, bool read);
    485486
    486487      // Component attributes

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

    r439 r449  
    518518    r_cas_rdata                = new sc_signal<data_t>[2];
    519519
     520    // Allocation for debug
     521    m_debug_previous_data      = new sc_signal<data_t>[nwords];
     522    m_debug_data               = new sc_signal<data_t>[nwords];
    520523
    521524    SC_METHOD(transition);
    … …  
    545548
    546549////////////////////////////////////////////////
    547 tmpl(void) ::check_monitor( const char  *buf,
    548                             addr_t      addr,
     550tmpl(void) ::check_monitor( addr_t      addr,
    549551                            data_t      data,
    550552                            bool        read )
    … …  
    554556      (addr < m_monitor_base + m_monitor_length))
    555557  {
    556     if ( read ) std::cout << " Monitor MEMC Read  ";
    557     else        std::cout << " Monitor MEMC Write ";
    558     std::cout << buf
    559               << " / Address = " << std::hex << addr
     558    if ( read ) std::cout << " Monitor MEMC Read ";
     559    else        std::cout << " Monitor MEMC Write";
     560    std::cout << " / Address = " << std::hex << addr
    560561              << " / Data = " << data
    561562              << " at cycle " << std::dec << m_cpt_cycles << std::endl;
    … …  
    564565
    565566/////////////////////////////////////////////////////
    566 tmpl(void) ::copies_monitor(addr_t addr)
     567tmpl(void) ::cache_monitor(addr_t addr)
    567568/////////////////////////////////////////////////////
    568569{
    569   DirectoryEntry entry = m_cache_directory.read_neutral(addr);
    570 
    571   if((entry.count != m_debug_previous_count) or
    572       (entry.valid != m_debug_previous_hit))
    573   {
    574     std::cout << "Monitor MEMC " << name()
    575               << " at cycle " << std::dec << m_cpt_cycles
    576               << " for address " << std::hex << addr
    577               << " / HIT = " << entry.valid
    578               << " / COUNT = " << std::dec << entry.count << std::endl;
    579   }
    580   m_debug_previous_count = entry.count;
    581   m_debug_previous_hit = entry.valid;
     570    size_t way = 0;
     571    size_t set = 0;
     572    DirectoryEntry entry = m_cache_directory.read_neutral(addr, &way, &set );
     573
     574    bool data_change = false;
     575
     576    if ( entry.valid )
     577    {
     578        m_cache_data.read_line( way, set, m_debug_data );
     579
     580        for ( size_t i = 0 ; i<m_words ; i++ )
     581        {
     582            if ( m_debug_previous_valid and
     583                 (m_debug_data[i].read() != m_debug_previous_data[i].read()) )
     584                 data_change = true;
     585            m_debug_previous_data[i] = m_debug_data[i].read();
     586        }
     587    }
     588   
     589    if ( (entry.valid != m_debug_previous_valid) or
     590         (entry.valid and (entry.count != m_debug_previous_count)) or
     591         (entry.valid and (entry.dirty != m_debug_previous_dirty)) or data_change )
     592    {
     593        std::cout << "Monitor MEMC " << name()
     594                  << " at cycle " << std::dec << m_cpt_cycles
     595                  << " for address " << std::hex << addr
     596                  << " / HIT = " << std::dec << entry.valid
     597                  << " / WAY = " << way
     598                  << " / COUNT = " << entry.count
     599                  << " / DIRTY = " << entry.dirty
     600                  << " / DATA_CHANGE = " << entry.count
     601                  << std::endl;
     602    }
     603    m_debug_previous_count = entry.count;
     604    m_debug_previous_valid = entry.valid;
     605    m_debug_previous_dirty = entry.dirty;
    582606}
    583607
    … …  
    683707
    684708    m_debug                = false;
    685     m_debug_previous_hit   = false;
     709    m_debug_previous_valid = false;
     710    m_debug_previous_dirty = false;
    686711    m_debug_previous_count = 0;
    687712
    … …  
    14281453  //
    14291454  // From the software point of view, a configuration request is a sequence
    1430   // of 6 atomic accesses:
     1455  // of 6 atomic accesses in an uncached segment:
    14311456  // - Read  MEMC_LOCK       : Get the lock
    14321457  // - Write MEMC_ADDR_LO    : Set the buffer address LSB
    … …  
    15831608                                  nb_copies,
    15841609                                  index);
     1610
    15851611                  if ( wok )  // UPT success => inval DIR slot
    15861612                  {
    … …  
    18651891        DirectoryEntry entry =
    18661892          m_cache_directory.read(m_cmd_read_addr_fifo.read(), way);
    1867         if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL)   // access the global table ONLY when we have an LL cmd
     1893        // access the global table ONLY when we have an LL cmd
     1894        if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL)   
    18681895        {
    18691896          r_read_ll_key   = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
    … …  
    19271954
    19281955    //////////////////
    1929     case READ_DIR_HIT:
    1930     {
    1931       //  read data in cache & update the directory
    1932       //  we enter this state in 3 cases:
    1933       //  - the read request is uncachable
    1934       //  - the cache line is in counter mode
    1935       //  - the cache line is valid but not replcated
    1936 
    1937       if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    1938       {
    1939         // check if this is an instruction read, this means pktid is either
    1940         // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
    1941         // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    1942         bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    1943         // check if this is a cached read, this means pktid is either
    1944         // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
    1945         // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    1946         bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
    1947         bool is_cnt       = r_read_is_cnt.read();
    1948 
    1949         // read data in the cache
    1950         size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    1951         size_t way        = r_read_way.read();
    1952 
    1953         m_cache_data.read_line(way, set, r_read_data);
    1954 
    1955         // update the cache directory
    1956         DirectoryEntry entry;
    1957         entry.valid   = true;
    1958         entry.is_cnt  = is_cnt;
    1959         entry.dirty   = r_read_dirty.read();
    1960         entry.tag     = r_read_tag.read();
    1961         entry.lock    = r_read_lock.read();
    1962         entry.ptr     = r_read_ptr.read();
    1963         if(cached_read)   // Cached read => we must update the copies
    1964         {
    1965           if(!is_cnt)  // Not counter mode
    1966           {
    1967             entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     1956    case READ_DIR_HIT:    //  read data in cache & update the directory
     1957                          //  we enter this state in 3 cases:
     1958                          //  - the read request is uncachable
     1959                          //  - the cache line is in counter mode
     1960                          //  - the cache line is valid but not replicated
     1961
     1962    {
     1963        if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     1964        {
     1965            // check if this is an instruction read, this means pktid is either
     1966            // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
     1967            // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     1968            bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
     1969            // check if this is a cached read, this means pktid is either
     1970            // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
     1971            // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     1972            bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
     1973            bool is_cnt       = r_read_is_cnt.read();
     1974
     1975            // read data in the cache
     1976            size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
     1977            size_t way        = r_read_way.read();
     1978
     1979            m_cache_data.read_line(way, set, r_read_data);
     1980
     1981            if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
     1982
     1983            // update the cache directory
     1984            DirectoryEntry entry;
     1985            entry.valid   = true;
     1986            entry.is_cnt  = is_cnt;
     1987            entry.dirty   = r_read_dirty.read();
     1988            entry.tag     = r_read_tag.read();
     1989            entry.lock    = r_read_lock.read();
     1990            entry.ptr     = r_read_ptr.read();
     1991
     1992            if(cached_read)   // Cached read => we must update the copies
     1993            {
     1994                if(!is_cnt)  // Not counter mode
     1995                {
     1996                    entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
    19681997#if L1_MULTI_CACHE
    1969             entry.owner.cache_id = m_cmd_read_pktid_fifo.read();
    1970 #endif
    1971             entry.owner.inst     = inst_read;
    1972             entry.count          = r_read_count.read() + 1;
    1973           }
    1974           else  // Counter mode
    1975           {
    1976             entry.owner.srcid    = 0;
     1998                    entry.owner.cache_id = m_cmd_read_pktid_fifo.read();
     1999#endif
     2000                    entry.owner.inst     = inst_read;
     2001                    entry.count          = r_read_count.read() + 1;
     2002                }
     2003                else  // Counter mode
     2004                {
     2005                    entry.owner.srcid    = 0;
    19772006#if L1_MULTI_CACHE
    1978             entry.owner.cache_id = 0;
    1979 #endif
    1980             entry.owner.inst     = false;
    1981             entry.count          = r_read_count.read() + 1;
    1982           }
    1983         }
    1984         else  // Uncached read
    1985         {
    1986           entry.owner.srcid     = r_read_copy.read();
     2007                    entry.owner.cache_id = 0;
     2008#endif
     2009                    entry.owner.inst     = false;
     2010                    entry.count          = r_read_count.read() + 1;
     2011                }
     2012            }
     2013            else            // Uncached read
     2014            {
     2015                entry.owner.srcid     = r_read_copy.read();
    19872016#if L1_MULTI_CACHE
    1988           entry.owner.cache_id  = r_read_copy_cache.read();
    1989 #endif
    1990           entry.owner.inst      = r_read_copy_inst.read();
    1991           entry.count           = r_read_count.read();
    1992         }
     2017                entry.owner.cache_id  = r_read_copy_cache.read();
     2018#endif
     2019                entry.owner.inst      = r_read_copy_inst.read();
     2020                entry.count           = r_read_count.read();
     2021            }
    19932022
    19942023#if DEBUG_MEMC_READ
    … …  
    20042033#endif
    20052034
    2006           if(m_monitor_ok)
    2007           {
    2008             char buf[80];
    2009             snprintf(buf, 80, "READ_DIR_HIT srcid %d, ins %d",
    2010                      (int)m_cmd_read_srcid_fifo.read(),
    2011                      (int)((m_cmd_read_pktid_fifo.read()&0x2)!=0));
    2012             check_monitor(buf, m_cmd_read_addr_fifo.read(), r_read_data[0], true);
    2013           }
    2014 
    2015 
    2016         m_cache_directory.write(set, way, entry);
    2017         r_read_fsm    = READ_RSP;
    2018       }
    2019       break;
    2020     }
    2021 
     2035            m_cache_directory.write(set, way, entry);
     2036            r_read_fsm    = READ_RSP;
     2037        }
     2038        break;
     2039    }
    20222040    ///////////////////
    20232041    case READ_HEAP_REQ:    // Get the lock to the HEAP directory
    … …  
    20502068
    20512069        m_cache_data.read_line(way, set, r_read_data);
     2070
     2071        if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
    20522072
    20532073        // update the cache directory
    … …  
    24172437
    24182438#if DEBUG_MEMC_WRITE
    2419         if(m_debug)
    2420         {
    2421           std::cout << "  <MEMC " << name() << " WRITE_IDLE> Write request "
    2422                     << " srcid = " << std::dec << m_cmd_write_srcid_fifo.read()
    2423                     << " / address = " << std::hex << m_cmd_write_addr_fifo.read()
    2424                     << " / data = " << m_cmd_write_data_fifo.read() << std::endl;
    2425         }
     2439if(m_debug)
     2440std::cout << "  <MEMC " << name() << " WRITE_IDLE> Write request "
     2441          << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
     2442          << " / address = " << std::hex << m_cmd_write_addr_fifo.read()
     2443          << " / data = " << m_cmd_write_data_fifo.read() << std::endl;
    24262444#endif
    24272445      }
    … …  
    24362454
    24372455#if DEBUG_MEMC_WRITE
    2438         if(m_debug)
    2439         {
    2440           std::cout << "  <MEMC " << name()
    2441                     << " WRITE_NEXT> Write another word in local buffer"
    2442                     << std::endl;
    2443         }
     2456if(m_debug)
     2457std::cout << "  <MEMC " << name()
     2458          << " WRITE_NEXT> Write another word in local buffer"
     2459          << std::endl;
    24442460#endif
    24452461        m_cpt_write_cells++;
    … …  
    25202536
    25212537#if DEBUG_MEMC_WRITE
    2522       if(m_debug)
    2523       {
    2524         std::cout
    2525             << "  <MEMC " << name() << " WRITE_DIR_REQ> Requesting DIR lock "
    2526             << std::endl;
    2527       }
     2538if(m_debug)
     2539std::cout << "  <MEMC " << name() << " WRITE_DIR_REQ> Requesting DIR lock "
     2540          << std::endl;
    25282541#endif
    25292542
    … …  
    25322545
    25332546    ////////////////////
    2534     case WRITE_DIR_LOCK:
    2535       // access directory to check hit/miss
     2547    case WRITE_DIR_LOCK:     // access directory to check hit/miss
    25362548    {
    25372549      if(r_alloc_dir_fsm.read() == ALLOC_DIR_WRITE)
    … …  
    25702582
    25712583#if DEBUG_MEMC_WRITE
    2572         if(m_debug)
    2573         {
    2574           std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> Check the directory: "
    2575                     << " address = " << std::hex << r_write_address.read()
    2576                     << " hit = " << std::dec << entry.valid
    2577                     << " count = " << entry.count
    2578                     << " is_cnt = " << entry.is_cnt << std::endl;
    2579           if((r_write_pktid.read() & 0x7) == TYPE_SC)
    2580             std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> global_llsc_table SC access" << std::endl;
    2581           else
    2582             std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> global_llsc_table SW access" << std::endl;
    2583         }
     2584if(m_debug)
     2585{
     2586std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> Check the directory: "
     2587          << " address = " << std::hex << r_write_address.read()
     2588          << " / hit = " << std::dec << entry.valid
     2589          << " / count = " << entry.count
     2590          << " / is_cnt = " << entry.is_cnt ;
     2591if((r_write_pktid.read() & 0x7) == TYPE_SC)
     2592std::cout << " / SC access" << std::endl;
     2593else
     2594std::cout << " / SW access" << std::endl;
     2595}
    25842596#endif
    25852597      }
    … …  
    25922604        exit(0);
    25932605      }
    2594 
    2595       break;
    2596     }
    2597 
     2606      break;
     2607    }
    25982608    ////////////////////
    25992609    case WRITE_DIR_READ:  // read the cache and complete the buffer when be!=0xF
    … …  
    26202630
    26212631#if DEBUG_MEMC_WRITE
    2622       if(m_debug)
    2623       {
    2624         std::cout << "  <MEMC " << name() << " WRITE_DIR_READ> Read the cache to complete local buffer" << std::endl;
    2625       }
     2632if(m_debug)
     2633std::cout << "  <MEMC " << name() << " WRITE_DIR_READ>"
     2634          << " Read the cache to complete local buffer" << std::endl;
    26262635#endif
    26272636      break;
    … …  
    26362645      entry.valid          = true;
    26372646      entry.dirty          = true;
    2638       entry.tag          = r_write_tag.read();
     2647      entry.tag            = r_write_tag.read();
    26392648      entry.is_cnt         = r_write_is_cnt.read();
    26402649      entry.lock           = r_write_lock.read();
    … …  
    26632672      // (tests for sc requests)
    26642673      bool no_update = ( (r_write_count.read() == 0) or
    2665                          (owner and (r_write_count.read() ==1) and (r_write_pktid.read() != TYPE_SC)));
     2674                         (owner and (r_write_count.read() ==1) and
     2675                         (r_write_pktid.read() != TYPE_SC)));
    26662676
    26672677      // write data in the cache if no coherence transaction
    … …  
    26752685          {
    26762686            addr_t address = (r_write_address.read() & ~(addr_t) 0x3F) | word<<2;
    2677             char buf[80];
    2678             snprintf(buf, 80, "WRITE_DIR_HIT srcid %d",
    2679                      (int)r_write_srcid.read());
    2680             check_monitor(buf, address, r_write_data[word].read(), false);
     2687            check_monitor( address, r_write_data[word].read(), false);
    26812688          }
    26822689        }
    … …  
    27272734      break;
    27282735    }
    2729 
    27302736    ////////////////////
    27312737    case WRITE_UPT_LOCK:  // Try to register the update request in UPT
    … …  
    27662772            {
    27672773              addr_t address = (r_write_address.read() & ~(addr_t) 0x3F) | word<<2;
    2768               char buf[80];
    2769               snprintf(buf, 80, "WRITE_UPT_LOCK srcid %d", (int)srcid);
    2770               check_monitor(buf, address, r_write_data[word].read(), false);
     2774              check_monitor( address, r_write_data[word].read(), false);
    27712775            }
    27722776          }
    … …  
    38683872        {
    38693873          addr_t address = r_xram_rsp_trt_buf.nline<<6 | word<<2;
    3870           check_monitor("XRAM_RSP_DIR_UPDT", address, r_xram_rsp_trt_buf.wdata[word], false);
     3874          check_monitor( address, r_xram_rsp_trt_buf.wdata[word], false);
    38713875        }
    38723876      }
    … …  
    52625266        {
    52635267          addr_t address = m_cmd_cas_addr_fifo.read();
    5264           char buf[80];
    5265           snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d",
    5266                    (int)m_cmd_cas_srcid_fifo.read());
    5267           check_monitor(buf, address, r_cas_wdata.read(), false);
     5268          check_monitor( address, r_cas_wdata.read(), false);
    52685269
    52695270          if(r_cas_cpt.read() == 4)
    5270             check_monitor(buf, address+4, m_cmd_cas_wdata_fifo.read(), false);
     5271            check_monitor( address+4, m_cmd_cas_wdata_fifo.read(), false);
    52715272        }
    52725273
    … …  
    53275328          {
    53285329            addr_t address = m_cmd_cas_addr_fifo.read();
    5329             char buf[80];
    5330             snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d",
    5331                      (int)m_cmd_cas_srcid_fifo.read());
    5332             check_monitor(buf, address, r_cas_wdata.read(), false);
     5330            check_monitor( address, r_cas_wdata.read(), false);
    53335331
    53345332            if(r_cas_cpt.read() ==4)
    5335               check_monitor(buf, address+4, m_cmd_cas_wdata_fifo.read(), false);
     5333              check_monitor( address+4, m_cmd_cas_wdata_fifo.read(), false);
    53365334          }
    53375335        }
    … …  
    55645562          {
    55655563            addr_t address = m_cmd_cas_addr_fifo.read();
    5566             char buf[80];
    5567             snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d",
    5568                      (int)m_cmd_cas_srcid_fifo.read());
    5569             check_monitor(buf, address, r_cas_wdata.read(), false);
     5564            check_monitor( address, r_cas_wdata.read(), false);
     5565
    55705566            if(r_cas_cpt.read() ==4)
    5571               check_monitor(buf, address+4, m_cmd_cas_wdata_fifo.read(), false);
     5567              check_monitor( address+4, m_cmd_cas_wdata_fifo.read(), false);
    55725568          }
    55735569          r_cas_upt_index = index;
Note: See TracChangeset for help on using the changeset viewer.