Ignore:
Timestamp:
Mar 27, 2013, 2:25:37 PM (12 years ago)
Author:
cfuguet
Message:

Bug fix in the vci_cc_vcache_wrapper and vci_mem_cache components
(and the corresponding dspin coherence versions)

vci_cc_vcache_wrapper:

In the VCI_CMD FSM of the cc_vcache, for the SC command as for the
CAS command, we must set the CONS bit in the VCI packet. In the
same manner we must unset the CONTIG bit in the VCI packet for these
two commands.
These two kind of commands have two flits with the same VCI address.

vci_mem_cache

In the state WRITE_DIR_REQ, we don't have to rewrite the registers
address or word index because they will be assigned with the correct
values in the WRITE_IDLE or WRITE_RSP states.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/v5/modules/vci_mem_cache_dspin_coherence/caba/source/src/vci_mem_cache_dspin_coherence.cpp

    r335 r336  
    19401940        // consume a word in the FIFO & write it in the local buffer
    19411941        cmd_write_fifo_get  = true;
    1942         r_write_pending_sc  = false;
    19431942        size_t index        = m_x[(vci_addr_t)(m_cmd_write_addr_fifo.read())];
    19441943
     
    19501949        r_write_trdid       = m_cmd_write_trdid_fifo.read();
    19511950        r_write_pktid       = m_cmd_write_pktid_fifo.read();
     1951        r_write_pending_sc  = false;
    19521952
    19531953        // initialize the be field for all words
     
    19551955        {
    19561956          if(word == index) r_write_be[word] = m_cmd_write_be_fifo.read();
    1957           else                 r_write_be[word] = 0x0;
    1958         }
    1959 
    1960         if(m_cmd_write_eop_fifo.read() || ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC))
     1957          else              r_write_be[word] = 0x0;
     1958        }
     1959
     1960        if (m_cmd_write_eop_fifo.read() || ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC))
    19611961        {
    19621962          r_write_fsm = WRITE_DIR_REQ;
     
    19891989        if(m_debug_write_fsm)
    19901990        {
    1991           std::cout << "  <MEMC " << name() << ".WRITE_NEXT> Write another word in local buffer"
     1991          std::cout << "  <MEMC " << name()
     1992                    << ".WRITE_NEXT> Write another word in local buffer"
    19921993                    << std::endl;
    19931994        }
     
    20072008        // consume a word in the FIFO & write it in the local buffer
    20082009        cmd_write_fifo_get  = true;
    2009         r_write_pending_sc  = false;
    20102010        size_t index        = r_write_word_index.read() + r_write_word_count.read();
    20112011
     
    20242024    ////////////////////
    20252025    case WRITE_DIR_REQ:
     2026    {
    20262027      // Get the lock to the directory
    2027     {
     2028      // and access the llsc_global_table
    20282029      if(r_alloc_dir_fsm.read() == ALLOC_DIR_WRITE)
    20292030      {
    2030         if(((r_write_pktid.read() & 0x7) == TYPE_SC) && not r_write_pending_sc.read())    // check for an SC command (and check that its second flit is not already consumed)
    2031         {
    2032           if(m_cmd_write_addr_fifo.rok())
    2033           {
    2034             size_t index    = m_x[(vci_addr_t)(r_write_address.read())];
    2035             bool sc_success = m_llsc_table.sc(r_write_address.read(),r_write_data[index].read());
    2036             r_write_sc_fail = !sc_success;
    2037 
    2038             assert(m_cmd_write_eop_fifo.read() && "Error in VCI_MEM_CACHE : invalid packet format for SC command");
    2039             // consume a word in the FIFO & write it in the local buffer
    2040             cmd_write_fifo_get  = true;
    2041             r_write_pending_sc  = true;
    2042             index               = m_x[(vci_addr_t)(m_cmd_write_addr_fifo.read())];
    2043 
    2044             r_write_address     = (addr_t)(m_cmd_write_addr_fifo.read());
    2045             r_write_word_index  = index;
    2046             r_write_word_count  = 1;
    2047             r_write_data[index] = m_cmd_write_data_fifo.read();
    2048             if(!sc_success)
    2049             {
    2050               r_write_fsm = WRITE_RSP;
    2051               break;
    2052             }
    2053           }
    2054           else break;
    2055         }
    2056         //else it is a TYPE_WRITE, need a simple sw access to the
    2057         // llsc_global_table
    2058         else
    2059         {
    2060           m_llsc_table.sw(r_write_address.read());
    2061         }
     2031        ///////////////////////////////////////////////////////////////////////
     2032        // SC command treatment
     2033        // We test the r_write_pending_sc register to know if we are returning
     2034        // from the WAIT state.
     2035        // In this case, the SC has already succeed and we cannot consume
     2036        // another time from the FIFO. Also, we don't have to test another
     2037        // time if the SC has succeed
     2038        if(((r_write_pktid.read() & 0x7) == TYPE_SC) and not r_write_pending_sc.read())
     2039        {
     2040          if(not m_cmd_write_addr_fifo.rok()) break;
     2041
     2042          assert(m_cmd_write_eop_fifo.read() &&
     2043                 "Error in VCI_MEM_CACHE : "
     2044                 "invalid packet format for SC command");
     2045
     2046          size_t index    = r_write_word_index.read();
     2047          bool sc_success = m_llsc_table.sc(r_write_address.read()    ,
     2048                                            r_write_data[index].read());
     2049
     2050          // consume a word in the FIFO & write it in the local buffer
     2051          cmd_write_fifo_get  = true;
     2052          r_write_data[index] = m_cmd_write_data_fifo.read();
     2053          r_write_sc_fail     = not sc_success;
     2054          r_write_pending_sc  = true;
     2055
     2056          if(not sc_success) r_write_fsm = WRITE_RSP;
     2057          else               r_write_fsm = WRITE_DIR_LOCK;
     2058
     2059          break;
     2060        }
     2061
     2062        ///////////////////////////////////////////////////////////////////////
     2063        // WRITE command treatment or SC command returning from the WAIT state
     2064        // In the second case, we must access the LL/SC global table to
     2065        // erase any possible new reservation when we release the lock on the
     2066        // directory
     2067        m_llsc_table.sw(r_write_address.read());
     2068
    20622069        r_write_fsm = WRITE_DIR_LOCK;
    20632070      }
     
    22312238
    22322239      if(no_update)
    2233         // Write transaction completed
     2240      // Write transaction completed
    22342241      {
    22352242        r_write_fsm = WRITE_RSP;
    22362243      }
    22372244      else
    2238         // coherence update required
     2245      // coherence update required
    22392246      {
    22402247        if(!r_write_to_cc_send_multi_req.read()   &&
     
    23232330        //  releases the lock protecting UPT and the DIR if no entry...
    23242331        if(wok) r_write_fsm = WRITE_UPT_HEAP_LOCK;
    2325         else       r_write_fsm = WRITE_WAIT;
     2332        else    r_write_fsm = WRITE_WAIT;
    23262333      }
    23272334      break;
     
    25392546          // consume a word in the FIFO & write it in the local buffer
    25402547          cmd_write_fifo_get  = true;
    2541           r_write_pending_sc  = false;
    25422548          size_t index        = m_x[(vci_addr_t)(m_cmd_write_addr_fifo.read())];
    25432549
     
    25492555          r_write_trdid       = m_cmd_write_trdid_fifo.read();
    25502556          r_write_pktid       = m_cmd_write_pktid_fifo.read();
     2557          r_write_pending_sc  = false;
    25512558
    25522559          // initialize the be field for all words
Note: See TracChangeset for help on using the changeset viewer.