Ignore:
Timestamp:
Apr 9, 2014, 9:47:15 PM (10 years ago)
Author:
haoliu
Message:

MESI Bug fixed.
To be continue.....

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/MESI/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r673 r674  
    31753175                            << " / way = " << std::dec << way
    31763176                            << " / count = " <<std::dec << entry.count
     3177                            << " / copy = " <<std::dec << entry.owner.srcid
    31773178                            << " / is_cnt = " << entry.is_cnt << std::endl;
    31783179                        if((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) std::cout << " / LL access" << std::endl;
     
    32873288                                    << "  <MEMC " << name() << " READ_IVT_INVAL_LOCK>"
    32883289                                    << " Inval req for a read for ownership request"
     3290                                    << " read copy = " << r_read_copy.read()
    32893291                                    << " count " << ivt_send_count << " " << r_read_count.read()
    32903292                                    << std::endl;
     
    49054907                                         not r_write_to_cc_send_brdcast_req.read() and 
    49064908                                            (r_write_inval_trt_send.read() or not r_write_to_cleanup_req.read());
     4909
    49074910                    if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    49084911                    {
     
    49154918                        addr_t      nline      = m_nline[(addr_t)(r_write_address.read())];
    49164919                        size_t      nb_copies  = r_write_count.read();
    4917 
    4918                         wok = m_ivt.set(false,        // it's an inval transaction
    4919                                         is_brdcast,   // it's a broadcast
    4920                                         true,         // response required
    4921                                         false,        // no acknowledge required
    4922                                         srcid,
    4923                                         trdid,
    4924                                         pktid,
    4925                                         nline,
    4926                                         nb_copies,
    4927                                         index);
     4920                        bool        ivt_full   = m_ivt.is_full();
     4921
     4922                       
     4923                        //r_write_ivt_index = index;
     4924
     4925                        if(not ivt_full and cc_send_valid) //avoid to deadlock, we make sure that we can send cc_send request.
     4926                        { 
     4927                            wok = m_ivt.set(false,        // it's an inval transaction
     4928                                            is_brdcast,   // it's a broadcast
     4929                                            true,         // response required
     4930                                            false,        // no acknowledge required
     4931                                            srcid,
     4932                                            trdid,
     4933                                            pktid,
     4934                                            nline,
     4935                                            nb_copies,
     4936                                            index);
     4937                         /*//   std::cout << " trt wait nline =" << std::hex << nline
     4938                                     << " write data " << std::hex << std::endl;*/
    49284939#if DEBUG_MEMC_WRITE
    49294940                        if( m_debug and wok )
    49304941                            std::cout << "  <MEMC " << name() << " WRITE_INVAL_IVT_LOCK> Register broadcast inval in IVT"
     4942                                << "ivt index = " << index
    49314943                                << " / nb_copies = " << r_write_count.read() << std::endl;
    49324944#endif
    4933                         //r_write_ivt_index = index;
    4934 
    4935                         if(wok and cc_send_valid) //avoid to deadlock, we make sure that we can send cc_send request.
    4936                         {   
    4937                          /*//   std::cout << " trt wait nline =" << std::hex << nline
    4938                                      << " write data " << std::hex << std::endl;*/
    4939 
    49404945                            for(size_t word=0 ; word<m_words ; word++)
    49414946                            {
     
    67606765                            << " CLEANUP_LOCKED_IVT_CLEAR> clear UPT entry"
    67616766                            << " contain data = " << r_cleanup_contains_data.read()
     6767                            << " srcid = " << r_cleanup_locked_srcid.read()
    67626768                            << " updt dir count =" << entry.count
    67636769                            << std::endl;
     
    1000110007        // The ALLOC_DIR FSM allocates the access to the directory and
    1000210008        // the data cache with a round robin priority between 6 user FSMs :
    10003         // The cyclic ordering is CONFIG > READ > WRITE > CAS > CLEANUP > XRAM_RSP
     10009        // The cyclic ordering is CONFIG > READ > WRITE > CAS > MULTI_ACK > CLEANUP > XRAM_RSP
    1000410010        // The ressource is always allocated.
     10011        // one important point is that the multi_ack alloc is always token before the cleanup alloc
    1000510012        /////////////////////////////////////////////////////////////////////////////////////
    1000610013
     
    1003710044                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    1003810045
     10046                    else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     10047                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
     10048
    1003910049                    else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    1004010050                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
     
    1004210052                    else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    1004310053                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    10044 
    10045                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    10046                         r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    1004710054
    1004810055                    else
     
    1007110078                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    1007210079
     10080                    else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     10081                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
     10082
    1007310083                    else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    1007410084                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
     
    1007610086                    else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    1007710087                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    10078 
    10079                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    10080                         r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    1008110088
    1008210089                    else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     
    1011010117                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    1011110118
     10119                    else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     10120                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
     10121
    1011210122                    else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    1011310123                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
     
    1011510125                    else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    1011610126                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    10117 
    10118                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    10119                         r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    1012010127
    1012110128                    else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     
    1015010157                    ((r_cas_fsm.read()        == CAS_MISS_TRT_LOCK)  and
    1015110158                     (r_alloc_trt_fsm.read()  == ALLOC_TRT_CAS)))
    10152                 {
    10153                     if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     10159                {                   
     10160                    if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     10161                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
     10162
     10163                    else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    1015410164                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    1015510165
    1015610166                    else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    1015710167                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    10158 
    10159                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    10160                         r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    1016110168
    1016210169                    else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     
    1017510182                    m_cpt_cas_fsm_dir_used++;
    1017610183                break;
    10177 
    10178                 ///////////////////////
    10179             case ALLOC_DIR_CLEANUP:    // allocated to CLEANUP FSM
    10180                 if((r_cleanup_fsm.read() != CLEANUP_DIR_REQ) and
    10181                    (r_cleanup_fsm.read() != CLEANUP_DIR_LOCK) and
    10182                    (r_cleanup_fsm.read() != CLEANUP_LOCKED_IVT_LOCK) and
    10183                    (r_cleanup_fsm.read() != CLEANUP_LOCKED_IVT_DECREMENT) and
    10184                    (r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) and
    10185                    (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK))
    10186                 {
    10187                     if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    10188                         r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    10189 
    10190                     else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    10191                         r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    10192 
    10193                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
    10194                         r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    10195 
    10196                     else if(r_read_fsm.read() == READ_DIR_REQ)
    10197                         r_alloc_dir_fsm = ALLOC_DIR_READ;
    10198 
    10199                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
    10200                         r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    10201 
    10202                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
    10203                         r_alloc_dir_fsm = ALLOC_DIR_CAS;
    10204 
    10205                     else
    10206                         m_cpt_dir_unused++;
    10207                 }
    10208                 else
    10209                     m_cpt_cleanup_fsm_dir_used++;
    10210                 break;
    10211 
    10212                 ////////////////////////
    10213             case ALLOC_DIR_XRAM_RSP:    // allocated to XRAM_RSP FSM
    10214                 if( (r_xram_rsp_fsm.read() != XRAM_RSP_DIR_LOCK) and
    10215                     (r_xram_rsp_fsm.read() != XRAM_RSP_TRT_COPY) and
    10216                     (r_xram_rsp_fsm.read() != XRAM_RSP_IVT_LOCK))
    10217                 {
    10218                     if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
    10219                         r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
    10220 
    10221                     else if(r_config_fsm.read() == CONFIG_DIR_REQ)
    10222                         r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    10223 
    10224                     else if(r_read_fsm.read() == READ_DIR_REQ)
    10225                         r_alloc_dir_fsm = ALLOC_DIR_READ;
    10226 
    10227                     else if(r_write_fsm.read() == WRITE_DIR_REQ)
    10228                         r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    10229 
    10230                     else if(r_cas_fsm.read() == CAS_DIR_REQ)
    10231                         r_alloc_dir_fsm = ALLOC_DIR_CAS;
    10232 
    10233                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    10234                         r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    10235 
    10236                     else
    10237                         m_cpt_dir_unused++;
    10238                 }
    10239                 else
    10240                     m_cpt_xram_rsp_fsm_dir_used++;
    10241                 break;
    10242 
    1024310184                ////////////////////////
    1024410185            case ALLOC_DIR_MULTI_ACK:    // allocated to MULTI_ACK FSM
     
    1025310194                 //    (r_alloc_heap_fsm.read() == ALLOC_HEAP_MULTI_ACK)))
    1025410195                {
    10255                     if(r_config_fsm.read() == CONFIG_DIR_REQ)
     10196                    if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     10197                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
     10198
     10199                    else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     10200                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
     10201
     10202                    else if(r_config_fsm.read() == CONFIG_DIR_REQ)
    1025610203                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
    1025710204
     
    1026510212                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
    1026610213
    10267                     else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    10268                         r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    10269 
    10270                     else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    10271                         r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    1027210214                    else
    1027310215                        m_cpt_dir_unused++;
     
    1027610218                    m_cpt_xram_rsp_fsm_dir_used++;
    1027710219                break;
    10278 
    10279 
     10220                ///////////////////////
     10221            case ALLOC_DIR_CLEANUP:    // allocated to CLEANUP FSM
     10222                if((r_cleanup_fsm.read() != CLEANUP_DIR_REQ) and
     10223                   (r_cleanup_fsm.read() != CLEANUP_DIR_LOCK) and
     10224                   (r_cleanup_fsm.read() != CLEANUP_LOCKED_IVT_LOCK) and
     10225                   (r_cleanup_fsm.read() != CLEANUP_LOCKED_IVT_DECREMENT) and
     10226                   (r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) and
     10227                   (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK))
     10228                {
     10229                    if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     10230                        r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
     10231
     10232                    else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     10233                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     10234
     10235                    else if(r_read_fsm.read() == READ_DIR_REQ)
     10236                        r_alloc_dir_fsm = ALLOC_DIR_READ;
     10237
     10238                    else if(r_write_fsm.read() == WRITE_DIR_REQ)
     10239                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
     10240
     10241                    else if(r_cas_fsm.read() == CAS_DIR_REQ)
     10242                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
     10243
     10244                    else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     10245                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
     10246
     10247                    else
     10248                        m_cpt_dir_unused++;
     10249                }
     10250                else
     10251                    m_cpt_cleanup_fsm_dir_used++;
     10252                break;
     10253
     10254                ////////////////////////
     10255            case ALLOC_DIR_XRAM_RSP:    // allocated to XRAM_RSP FSM
     10256                if( (r_xram_rsp_fsm.read() != XRAM_RSP_DIR_LOCK) and
     10257                    (r_xram_rsp_fsm.read() != XRAM_RSP_TRT_COPY) and
     10258                    (r_xram_rsp_fsm.read() != XRAM_RSP_IVT_LOCK))
     10259                {
     10260                    if(r_config_fsm.read() == CONFIG_DIR_REQ)
     10261                        r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     10262
     10263                    else if(r_read_fsm.read() == READ_DIR_REQ)
     10264                        r_alloc_dir_fsm = ALLOC_DIR_READ;
     10265
     10266                    else if(r_write_fsm.read() == WRITE_DIR_REQ)
     10267                        r_alloc_dir_fsm = ALLOC_DIR_WRITE;
     10268
     10269                    else if(r_cas_fsm.read() == CAS_DIR_REQ)
     10270                        r_alloc_dir_fsm = ALLOC_DIR_CAS;
     10271
     10272                    else if(r_multi_ack_fsm.read() == MULTI_ACK_DIR_REQ)
     10273                        r_alloc_dir_fsm = ALLOC_DIR_MULTI_ACK;
     10274
     10275                    else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     10276                        r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
     10277
     10278                    else
     10279                        m_cpt_dir_unused++;
     10280                }
     10281                else
     10282                    m_cpt_xram_rsp_fsm_dir_used++;
     10283                break;
    1028010284
    1028110285        } // end switch alloc_dir_fsm
Note: See TracChangeset for help on using the changeset viewer.