Changeset 481


Ignore:
Timestamp:
Aug 2, 2013, 2:38:51 PM (9 years ago)
Author:
devigne
Message:

Fixing deadlock with MULTI_ACK FSM and TGT_RSP FSM, and CLEANUP_FSM and TGT_FSM
TGT_RSP FSM is now a client of UPT and IVT.

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

Legend:

Unmodified
Added
Removed
  • trunk/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r468 r481  
    104104        TGT_RSP_XRAM,
    105105        TGT_RSP_MULTI_ACK,
    106         TGT_RSP_CLEANUP
     106        TGT_RSP_CLEANUP,
     107        TGT_RSP_UPT_LOCK,
     108        TGT_RSP_IVT_LOCK
    107109      };
    108110
     
    333335        ALLOC_UPT_WRITE,
    334336        ALLOC_UPT_CAS,
    335         ALLOC_UPT_MULTI_ACK
     337        ALLOC_UPT_MULTI_ACK,
     338        ALLOC_UPT_TGT_RSP
    336339      };
    337340
     
    343346        ALLOC_IVT_CLEANUP,
    344347        ALLOC_IVT_CAS,
    345         ALLOC_IVT_CONFIG
     348        ALLOC_IVT_CONFIG,
     349        ALLOC_IVT_TGT_RSP
    346350      };
    347351
     
    492496      void genMoore();
    493497      void check_monitor(addr_t addr, data_t data, bool read);
     498      bool hit_cleanup_req(size_t *index);
     499      bool hit_multi_ack_req(size_t *index);
    494500
    495501      // Component attributes
     
    510516      TransactionTab                     m_trt;              // xram transaction table
    511517      uint32_t                           m_upt_lines;
     518      uint32_t                           m_ivt_lines;
    512519      UpdateTab                          m_upt;              // pending update
    513520      UpdateTab                          m_ivt;              // pending invalidate
     
    736743
    737744      // Buffer between MULTI_ACK fsm and TGT_RSP fsm (complete write/update transaction)
    738       sc_signal<bool>     r_multi_ack_to_tgt_rsp_req;   // valid request
     745      sc_signal<bool>     *r_multi_ack_to_tgt_rsp_req;  // valid request
    739746      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_srcid; // Transaction srcid
    740747      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_trdid; // Transaction trdid
     
    784791       
    785792      // Buffer between CLEANUP fsm and TGT_RSP fsm (acknowledge a write command from L1)
    786       sc_signal<bool>     r_cleanup_to_tgt_rsp_req;   // valid request
     793      sc_signal<bool>     *r_cleanup_to_tgt_rsp_req;   // valid request
    787794      sc_signal<size_t>   r_cleanup_to_tgt_rsp_srcid; // transaction srcid
    788795      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
     
    919926      sc_signal<int>      r_tgt_rsp_fsm;
    920927      sc_signal<size_t>   r_tgt_rsp_cpt;
     928      sc_signal<size_t>   r_tgt_rsp_prio_multi_ack;
     929      sc_signal<size_t>   r_tgt_rsp_prio_cleanup;
    921930      sc_signal<bool>     r_tgt_rsp_key_sent;
    922931
  • trunk/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r468 r481  
    8484  "TGT_RSP_XRAM",
    8585  "TGT_RSP_MULTI_ACK",
    86   "TGT_RSP_CLEANUP"
     86  "TGT_RSP_CLEANUP",
     87  "TGT_RSP_UPT_LOCK",
     88  "TGT_RSP_IVT_LOCK"
    8789};
    8890const char *cc_receive_fsm_str[] =
     
    285287  "ALLOC_UPT_WRITE",
    286288  "ALLOC_UPT_CAS",
    287   "ALLOC_UPT_MULTI_ACK"
     289  "ALLOC_UPT_MULTI_ACK",
     290  "ALLOC_UPT_TGT_RSP"
    288291};
    289292const char *alloc_ivt_fsm_str[] =
     
    293296  "ALLOC_IVT_CLEANUP",
    294297  "ALLOC_IVT_CAS",
    295   "ALLOC_IVT_CONFIG"
     298  "ALLOC_IVT_CONFIG",
     299  "ALLOC_IVT_TGT_RSP"
    296300};
    297301const char *alloc_heap_fsm_str[] =
     
    361365    m_trt(this->name(), trt_lines, nwords),
    362366    m_upt_lines(upt_lines),
     367    m_ivt_lines(ivt_lines),
    363368    m_upt(upt_lines),
    364369    m_ivt(ivt_lines),
     
    502507        i++;
    503508    }
     509    // Allocation for MULTI_ACK FSM
     510    r_multi_ack_to_tgt_rsp_req = new sc_signal<bool>[m_upt_lines];
     511    r_cleanup_to_tgt_rsp_req   = new sc_signal<bool>[m_ivt_lines];
    504512
    505513    // Allocation for IXR_RSP FSM
     
    571579              << " at cycle " << std::dec << m_cpt_cycles << std::endl;
    572580  }
     581}
     582// Index is the value of the current priority
     583///////////////////////////////////////////////////////////////////////
     584tmpl(bool) ::hit_cleanup_req(size_t *index)
     585///////////////////////////////////////////////////////////////////////
     586{
     587  size_t i = *index;
     588  do
     589  {
     590    if(r_cleanup_to_tgt_rsp_req[i].read())
     591    {
     592      *index = i;
     593      return true;
     594    }
     595    i = (i + 1) % m_ivt_lines;
     596  } while (i != *index);
     597  return false;
     598}
     599
     600// Index is the value of the current priority
     601///////////////////////////////////////////////////////////////////////
     602tmpl(bool) ::hit_multi_ack_req(size_t *index)
     603///////////////////////////////////////////////////////////////////////
     604{
     605  size_t i = *index;
     606  do
     607  {
     608    if(r_multi_ack_to_tgt_rsp_req[i].read())
     609    {
     610      *index = i;
     611      return true;
     612    }
     613    i = (i + 1) % m_upt_lines;
     614  } while (i != *index);
     615  return false;
    573616}
    574617
     
    674717{
    675718  delete [] r_ixr_rsp_to_xram_rsp_rok;
    676 
     719  delete [] r_multi_ack_to_tgt_rsp_req;
     720  delete [] r_cleanup_to_tgt_rsp_req;
    677721  delete [] r_xram_rsp_victim_data;
    678722  delete [] r_xram_rsp_to_tgt_rsp_data;
     
    776820#endif
    777821
    778     r_cleanup_to_tgt_rsp_req      = false;
    779 
    780822    m_cc_receive_to_cleanup_fifo.init();
    781 
    782     r_multi_ack_to_tgt_rsp_req     = false;
     823    for(size_t i = 0; i < m_upt_lines; i++)
     824    {
     825      r_multi_ack_to_tgt_rsp_req[i] = false;
     826    }
     827    for(size_t i = 0; i < m_ivt_lines; i++)
     828    {
     829      r_cleanup_to_tgt_rsp_req[i] = false;
     830    }
    783831
    784832    m_cc_receive_to_multi_ack_fifo.init();
     
    818866    r_alloc_heap_reset_cpt = 0;
    819867
    820     r_tgt_rsp_key_sent  = false;
     868    r_tgt_rsp_key_sent        = false;
     869    r_tgt_rsp_prio_multi_ack  = 0;
     870    r_tgt_rsp_prio_cleanup  = 0;
    821871
    822872    // Activity counters
     
    13371387        size_t count = 0;
    13381388        bool valid   = m_upt.decrement(r_multi_ack_upt_index.read(), count);
     1389       
     1390        bool need_rsp     = m_upt.need_rsp(r_multi_ack_upt_index.read());
    13391391
    13401392        if(not valid)
     
    13461398        }
    13471399
    1348         if(count == 0)
     1400        if(count == 0 and need_rsp)
     1401        {
     1402          r_multi_ack_fsm = MULTI_ACK_WRITE_RSP;
     1403        }
     1404        else if(count == 0)
    13491405        {
    13501406          r_multi_ack_fsm = MULTI_ACK_UPT_CLEAR;
     
    13801436        r_multi_ack_pktid = m_upt.pktid(r_multi_ack_upt_index.read());
    13811437        r_multi_ack_nline = m_upt.nline(r_multi_ack_upt_index.read());
    1382         bool need_rsp     = m_upt.need_rsp(r_multi_ack_upt_index.read());
    13831438        bool need_ack     = m_upt.need_ack(r_multi_ack_upt_index.read());
    13841439
     
    13861441        m_upt.clear(r_multi_ack_upt_index.read());
    13871442
    1388         if      ( need_rsp ) r_multi_ack_fsm = MULTI_ACK_WRITE_RSP;
    1389         else if ( need_ack ) r_multi_ack_fsm = MULTI_ACK_CONFIG_ACK;
     1443        if ( need_ack )      r_multi_ack_fsm = MULTI_ACK_CONFIG_ACK;
    13901444        else                 r_multi_ack_fsm = MULTI_ACK_IDLE;
    13911445
     
    14001454    /////////////////////////
    14011455    case MULTI_ACK_WRITE_RSP:     // Post a response request to TGT_RSP FSM
    1402                                   // Wait if pending request
    1403     {
    1404         if ( r_multi_ack_to_tgt_rsp_req.read() ) break;
    1405 
    1406         r_multi_ack_to_tgt_rsp_req   = true;
    1407         r_multi_ack_to_tgt_rsp_srcid = r_multi_ack_srcid.read();
    1408         r_multi_ack_to_tgt_rsp_trdid = r_multi_ack_trdid.read();
    1409         r_multi_ack_to_tgt_rsp_pktid = r_multi_ack_pktid.read();
    1410         r_multi_ack_fsm              = MULTI_ACK_IDLE;
     1456    {
     1457        r_multi_ack_to_tgt_rsp_req[r_multi_ack_upt_index.read()]   = true;
     1458        r_multi_ack_fsm = MULTI_ACK_IDLE;
    14111459
    14121460#if DEBUG_MEMC_MULTI_ACK
    14131461if(m_debug)
    14141462std::cout << "  <MEMC " << name() << " MULTI_ACK_WRITE_RSP>"
    1415           << " Request TGT_RSP FSM to send a response to srcid "
    1416           << std::hex << r_multi_ack_srcid.read() << std::endl;
     1463          << " Request TGT_RSP FSM to send a response"
     1464          << " / Request for upt index " << r_multi_ack_upt_index.read() << std::endl;
    14171465#endif
    14181466        break;
     
    49134961      size_t count = 0;
    49144962      m_ivt.decrement(r_cleanup_index.read(), count);
    4915 
    4916       if(count == 0)   // multi inval transaction completed
     4963     
     4964      if((count == 0) and r_cleanup_need_rsp.read())   // multi inval transaction completed
     4965      {
     4966        r_cleanup_fsm = CLEANUP_WRITE_RSP;
     4967      }
     4968      else if(count == 0)   // multi inval transaction completed
    49174969      {
    49184970        r_cleanup_fsm = CLEANUP_IVT_CLEAR;
     
    49485000      m_ivt.clear(r_cleanup_index.read());
    49495001
    4950       if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
    4951       else if ( r_cleanup_need_ack.read() ) r_cleanup_fsm = CLEANUP_CONFIG_ACK;
     5002      if ( r_cleanup_need_ack.read() )      r_cleanup_fsm = CLEANUP_CONFIG_ACK;
    49525003      else                                  r_cleanup_fsm = CLEANUP_SEND_CLACK;
    49535004
     
    49645015                               // wait if pending request to the TGT_RSP FSM
    49655016    {
    4966       if(r_cleanup_to_tgt_rsp_req.read()) break;
    49675017
    49685018      // no pending request
    4969       r_cleanup_to_tgt_rsp_req     = true;
    4970       r_cleanup_to_tgt_rsp_srcid   = r_cleanup_write_srcid.read();
    4971       r_cleanup_to_tgt_rsp_trdid   = r_cleanup_write_trdid.read();
    4972       r_cleanup_to_tgt_rsp_pktid   = r_cleanup_write_pktid.read();
     5019      r_cleanup_to_tgt_rsp_req[r_cleanup_index.read()]     = true;
    49735020
    49745021      r_cleanup_fsm                = CLEANUP_SEND_CLACK;
     
    49775024if(m_debug)
    49785025std::cout << "  <MEMC " << name() << " CLEANUP_WRITE_RSP>"
    4979           << " Send a response to a previous write request: "
    4980           << " rsrcid = "   << std::hex << r_cleanup_write_srcid.read()
    4981           << " / rtrdid = " << r_cleanup_write_trdid.read()
    4982           << " / rpktid = " << r_cleanup_write_pktid.read() << std::endl;
     5026          << " Send a response to a previous write request"
     5027          << std::endl;
    49835028#endif
    49845029      break;
     
    64856530    case TGT_RSP_CONFIG_IDLE:  // tgt_cmd requests have the highest priority
    64866531    {
     6532      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6533      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
    64876534      if(r_tgt_cmd_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
    64886535      else if(r_read_to_tgt_rsp_req)
     
    64986545        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    64996546      }
    6500       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    6501       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6547      else if(hit_multi_ack_req(&prio_multi_ack))
     6548      {
     6549        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6550        // update rr priority
     6551        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6552      }
     6553      else if(hit_cleanup_req(&prio_cleanup))
     6554      {
     6555        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6556        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6557      }
    65026558      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    65036559      break;
     
    65066562    case TGT_RSP_TGT_CMD_IDLE: // read requests have the highest priority
    65076563    {
     6564      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6565      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
    65086566      if(r_read_to_tgt_rsp_req)
    65096567      {
     
    65186576        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    65196577      }
    6520       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    6521       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6578      else if(hit_multi_ack_req(&prio_multi_ack))
     6579      {
     6580        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6581        // update rr priority
     6582        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6583      }
     6584      else if(hit_cleanup_req(&prio_cleanup))
     6585      {
     6586        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6587        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6588      }
    65226589      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    65236590      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    65276594    case TGT_RSP_READ_IDLE: // write requests have the highest priority
    65286595    {
     6596      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6597      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
    65296598      if(r_write_to_tgt_rsp_req)          r_tgt_rsp_fsm = TGT_RSP_WRITE;
    65306599      else if(r_cas_to_tgt_rsp_req)       r_tgt_rsp_fsm = TGT_RSP_CAS;
     
    65346603        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    65356604      }
    6536       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    6537       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6605      else if(hit_multi_ack_req(&prio_multi_ack))
     6606      {
     6607        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6608        // update rr priority
     6609        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6610      }
     6611      else if(hit_cleanup_req(&prio_cleanup))
     6612      {
     6613        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6614        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6615      }
    65386616      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    65396617      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    65486626    case TGT_RSP_WRITE_IDLE: // cas requests have the highest priority
    65496627    {
     6628      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6629      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
    65506630      if(r_cas_to_tgt_rsp_req)            r_tgt_rsp_fsm = TGT_RSP_CAS;
    65516631      else if(r_xram_rsp_to_tgt_rsp_req)
     
    65546634        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    65556635      }
    6556       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    6557       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6636      else if(hit_multi_ack_req(&prio_multi_ack))
     6637      {
     6638        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6639        // update rr priority
     6640        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6641      }
     6642      else if(hit_cleanup_req(&prio_cleanup))
     6643      {
     6644        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6645        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6646      }
    65586647      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    65596648      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    65696658    case TGT_RSP_CAS_IDLE: // xram_rsp requests have the highest priority
    65706659    {
     6660      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6661      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
    65716662      if(r_xram_rsp_to_tgt_rsp_req)
    65726663      {
     
    65746665        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    65756666      }
    6576       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK   ;
    6577       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6667      else if(hit_multi_ack_req(&prio_multi_ack))
     6668      {
     6669        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6670        // update rr priority
     6671        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6672      }
     6673      else if(hit_cleanup_req(&prio_cleanup))
     6674      {
     6675        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6676        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6677      }
    65786678      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    65796679      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    65906690    case TGT_RSP_XRAM_IDLE: // multi ack requests have the highest priority
    65916691    {
    6592 
    6593       if(r_multi_ack_to_tgt_rsp_req)      r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK   ;
    6594       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6692      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6693      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
     6694
     6695      if(hit_multi_ack_req(&prio_multi_ack))
     6696      {
     6697        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6698        // update rr priority
     6699        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6700      }
     6701      else if(hit_cleanup_req(&prio_cleanup))
     6702      {
     6703        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6704        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6705      }
    65956706      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    65966707      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    66126723    case TGT_RSP_MULTI_ACK_IDLE: // cleanup requests have the highest priority
    66136724    {
    6614       if(r_cleanup_to_tgt_rsp_req)        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6725      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6726      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
     6727      if(hit_cleanup_req(&prio_cleanup))
     6728      {
     6729        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6730        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6731      }
    66156732      else if(r_config_to_tgt_rsp_req)    r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    66166733      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    66276744        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    66286745      }
    6629       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
     6746      else if(hit_multi_ack_req(&prio_multi_ack))
     6747      {
     6748        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6749        // update rr priority
     6750        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6751      }
    66306752      break;
    66316753    }
     
    66336755    case TGT_RSP_CLEANUP_IDLE: // tgt cmd requests have the highest priority
    66346756    {
     6757      size_t prio_multi_ack = r_tgt_rsp_prio_multi_ack.read();
     6758      size_t prio_cleanup   = r_tgt_rsp_prio_cleanup.read();
    66356759      if(r_config_to_tgt_rsp_req)         r_tgt_rsp_fsm = TGT_RSP_CONFIG;
    66366760      else if(r_tgt_cmd_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     
    66476771        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    66486772      }
    6649       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK   ;
    6650       else if(r_cleanup_to_tgt_rsp_req)   r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6773      else if(hit_multi_ack_req(&prio_multi_ack))
     6774      {
     6775        r_tgt_rsp_fsm = TGT_RSP_UPT_LOCK;
     6776        // update rr priority
     6777        r_tgt_rsp_prio_multi_ack = prio_multi_ack;
     6778      }
     6779      else if(hit_cleanup_req(&prio_cleanup))
     6780      {
     6781        r_tgt_rsp_fsm = TGT_RSP_IVT_LOCK;
     6782        r_tgt_rsp_prio_cleanup = prio_cleanup;
     6783      }
    66516784      break;
    66526785    }
     
    67616894      break;
    67626895    }
     6896   
     6897    ///////////////////////
     6898    case TGT_RSP_IVT_LOCK:      // Clear IVT entry
     6899    {
     6900      if (r_alloc_ivt_fsm.read() != ALLOC_IVT_TGT_RSP) break;
     6901
     6902      r_cleanup_to_tgt_rsp_srcid = m_ivt.srcid(r_tgt_rsp_prio_cleanup.read());
     6903      r_cleanup_to_tgt_rsp_trdid = m_ivt.trdid(r_tgt_rsp_prio_cleanup.read());
     6904      r_cleanup_to_tgt_rsp_pktid = m_ivt.pktid(r_tgt_rsp_prio_cleanup.read());
     6905
     6906      m_ivt.clear(r_tgt_rsp_prio_cleanup.read());
     6907
     6908      r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6909      break;
     6910    }
     6911
    67636912    /////////////////////
    67646913    case TGT_RSP_CLEANUP:   // pas clair pour moi (AG)
     
    67756924#endif
    67766925        r_tgt_rsp_fsm = TGT_RSP_CLEANUP_IDLE;
    6777         r_cleanup_to_tgt_rsp_req = false;
     6926        r_cleanup_to_tgt_rsp_req[r_tgt_rsp_prio_cleanup.read()] = false;
     6927        r_tgt_rsp_prio_cleanup = (r_tgt_rsp_prio_cleanup.read() + 1) % m_ivt_lines;
    67786928      }
    67796929      break;
     
    68416991    }
    68426992    ///////////////////////
     6993    case TGT_RSP_UPT_LOCK:      // Clear UPT entry
     6994    {
     6995      if (r_alloc_upt_fsm.read() != ALLOC_UPT_TGT_RSP) break;
     6996
     6997      r_multi_ack_to_tgt_rsp_srcid = m_upt.srcid(r_tgt_rsp_prio_multi_ack.read());
     6998      r_multi_ack_to_tgt_rsp_trdid = m_upt.trdid(r_tgt_rsp_prio_multi_ack.read());
     6999      r_multi_ack_to_tgt_rsp_pktid = m_upt.pktid(r_tgt_rsp_prio_multi_ack.read());
     7000
     7001      m_upt.clear(r_tgt_rsp_prio_multi_ack.read());
     7002
     7003      r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
     7004      break;
     7005    }
     7006
     7007    ///////////////////////
    68437008    case TGT_RSP_MULTI_ACK:    // send the write response after coherence transaction
    68447009    {
     
    68547019#endif
    68557020        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK_IDLE;
    6856         r_multi_ack_to_tgt_rsp_req = false;
     7021        r_multi_ack_to_tgt_rsp_req[r_tgt_rsp_prio_multi_ack.read()] = false;
     7022        r_tgt_rsp_prio_multi_ack = (r_tgt_rsp_prio_multi_ack.read() + 1) % m_upt_lines;
    68577023      }
    68587024      break;
     
    68827048              else if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    68837049                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     7050             
     7051              else if (r_tgt_rsp_fsm.read() == TGT_RSP_UPT_LOCK)
     7052                  r_alloc_upt_fsm = ALLOC_UPT_TGT_RSP;
    68847053          }
    68857054          break;
     
    68917060              if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    68927061                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     7062             
     7063              else if (r_tgt_rsp_fsm.read() == TGT_RSP_UPT_LOCK)
     7064                  r_alloc_upt_fsm = ALLOC_UPT_TGT_RSP;
    68937065
    68947066              else if (r_write_fsm.read() == WRITE_UPT_LOCK)
     
    69027074              (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
    69037075          {
     7076              if (r_tgt_rsp_fsm.read() == TGT_RSP_UPT_LOCK)
     7077                  r_alloc_upt_fsm = ALLOC_UPT_TGT_RSP;
     7078             
     7079              else if (r_write_fsm.read() == WRITE_UPT_LOCK)
     7080                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     7081
     7082              else if (r_cas_fsm.read() == CAS_UPT_LOCK)
     7083                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     7084          }
     7085          break;
     7086     
     7087      /////////////////////////
     7088      case ALLOC_UPT_TGT_RSP:     // allocated to TGT_RSP FSM
     7089          if (r_tgt_rsp_fsm.read() != TGT_RSP_UPT_LOCK )
     7090          {
    69047091              if (r_write_fsm.read() == WRITE_UPT_LOCK)
    69057092                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     
    69077094              else if (r_cas_fsm.read() == CAS_UPT_LOCK)
    69087095                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     7096             
     7097              else if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     7098                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     7099             
    69097100          }
    69107101          break;
     
    69437134              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
    69447135                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7136             
     7137              else if (r_tgt_rsp_fsm.read() == TGT_RSP_IVT_LOCK)
     7138                  r_alloc_ivt_fsm = ALLOC_IVT_TGT_RSP;
    69457139          }
    69467140          break;
     
    69587152              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
    69597153                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7154             
     7155              else if (r_tgt_rsp_fsm.read() == TGT_RSP_IVT_LOCK)
     7156                  r_alloc_ivt_fsm = ALLOC_IVT_TGT_RSP;
    69607157
    69617158              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     
    69747171              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
    69757172                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7173             
     7174              else if (r_tgt_rsp_fsm.read() == TGT_RSP_IVT_LOCK)
     7175                  r_alloc_ivt_fsm = ALLOC_IVT_TGT_RSP;
    69767176
    69777177              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     
    69897189              if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
    69907190                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7191             
     7192              else if (r_tgt_rsp_fsm.read() == TGT_RSP_IVT_LOCK)
     7193                  r_alloc_ivt_fsm = ALLOC_IVT_TGT_RSP;
    69917194
    69927195              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     
    70047207      case ALLOC_IVT_CONFIG:           // allocated to CONFIG FSM
    70057208          if (r_config_fsm.read() != CONFIG_DIR_IVT_LOCK)
    7006           {
     7209          {
     7210              if (r_tgt_rsp_fsm.read() == TGT_RSP_IVT_LOCK)
     7211                  r_alloc_ivt_fsm = ALLOC_IVT_TGT_RSP;
     7212             
     7213              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7214                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7215
     7216              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7217                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7218
     7219              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7220                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7221
     7222              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7223                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7224          }
     7225          break;
     7226     
     7227      //////////////////////////
     7228      case ALLOC_IVT_TGT_RSP:           // allocated to TGT RSP FSM
     7229          if (r_tgt_rsp_fsm.read() != TGT_RSP_IVT_LOCK)
     7230          {
    70077231              if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
    70087232                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     
    70167240              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
    70177241                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7242             
     7243              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7244                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
    70187245          }
    70197246          break;
Note: See TracChangeset for help on using the changeset viewer.