Ignore:
Timestamp:
Aug 20, 2013, 2:13:08 PM (11 years ago)
Author:
devigne
Message:

Merge with the lastest version of trunk

Location:
branches/ODCCP/modules/vci_cc_vcache_wrapper
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/ODCCP/modules/vci_cc_vcache_wrapper

  • branches/ODCCP/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r492 r494  
    3636#define DEBUG_CLEANUP             1
    3737#define INSTRUMENTATION       1
    38 #define FETCH_ON_WRITE_ENABLE 0
     38#define FETCH_ON_WRITE_ENABLE 1
    3939#define DEBUG_CMD                 0
    4040
    … …  
    285285      r_icache_tlb_rsp_error("r_icache_tlb_rsp_error"),
    286286
     287      r_icache_cleanup_victim_req("r_icache_cleanup_victim_req"),
     288      r_icache_cleanup_victim_nline("r_icache_cleanup_victim_nline"),
     289
    287290      r_icache_cc_send_req("r_icache_cc_send_req"),
    288291      r_icache_cc_send_type("r_icache_cc_send_type"),
    … …  
    357360      r_dcache_xtn_opcode("r_dcache_xtn_opcode"),
    358361
     362      r_dcache_cleanup_victim_req("r_dcache_cleanup_victim_req"),
     363      r_dcache_cleanup_victim_nline("r_dcache_cleanup_victim_nline"),
     364   
    359365      r_dcache_cc_send_req("r_dcache_cc_send_req"),
    360366      r_dcache_cc_send_type("r_dcache_cc_send_type"),
    … …  
    363369      r_dcache_cc_send_updt_tab_idx("r_dcache_cc_send_updt_tab_idx"),
    364370     
    365       r_cc_send_data_fifo("r_cc_send_data_fifo", 2),  // ODCCP
     371      r_cc_send_data_fifo("r_cc_send_data_fifo", 16),  // ODCCP
    366372
    367373      r_vci_cmd_fsm("r_vci_cmd_fsm"),
    … …  
    792798        // No request from ICACHE_FSM to CC_SEND FSM
    793799        r_icache_cc_send_req       = false;
     800        r_icache_cleanup_victim_req = false;
    794801
    795802        r_icache_clack_req         = false;
    … …  
    814821        // No request from DCACHE FSM to CC_SEND FSM
    815822        r_dcache_cc_send_req       = false;
    816 
     823        r_dcache_cleanup_victim_req = false;
     824   
    817825        r_dcache_clack_req         = false;
    818826
    … …  
    852860        r_dcache_miss_data_cpt               = 0;
    853861        r_dcache_miss_data_addr              = 0;
     862        //r_miss_cleanup_ncc_pending           = false;
    854863
    855864        // activity counters
    … …  
    10931102
    10941103        // coherence interrupt
    1095         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1104        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    10961105        {
    10971106            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    13301339
    13311340        // coherence interrupt
    1332         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1341        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    13331342        {
    13341343            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    13821391
    13831392        // coherence request (from CC_RECEIVE FSM)
    1384         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1393        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    13851394        {
    13861395            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    15721581    ////////////////////////
    15731582    case ICACHE_MISS_SELECT:       // Try to select a slot in associative set,
    1574                                    // if previous cleanup has been sent.
    15751583                                   // Waiting in this state if no slot available.
    1576                                    // Set the r_icache_cleanup_req flip-flop
    1577                                    // and the r_icache_miss_clack flip-flop,
     1584                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
     1585                                   // we send the cleanup request in this state.
     1586                                   // If not, a r_icache_cleanup_victim_req flip-flop is
     1587                                   // utilized for saving this cleanup request, and it will be sent later
     1588                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
     1589                                   // The r_icache_miss_clack flip-flop is set
    15781590                                   // when a cleanup is required
    15791591    {
    … …  
    15891601
    15901602        // coherence interrupt
    1591         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1603        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    15921604        {
    15931605            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    15961608        }
    15971609
    1598         if ( not r_icache_cc_send_req.read() ) // wait for previous cc_send request to be sent
    1599         {
    1600             bool        found;
    1601             bool        cleanup;
    1602             size_t      way;
    1603             size_t      set;
    1604             paddr_t     victim;
     1610
     1611        bool        found;
     1612        bool        cleanup;
     1613        size_t          way;
     1614        size_t          set;
     1615        paddr_t         victim;
    16051616
    16061617#ifdef INSTRUMENTATION
    16071618m_cpt_icache_dir_read++;
    16081619#endif
    1609             r_icache.read_select(r_icache_vci_paddr.read(),
    1610                                  &victim,
    1611                                  &way,
    1612                                  &set,
    1613                                  &found,
    1614                                  &cleanup );
    1615             if ( found )
    1616             {
    1617                 r_icache_miss_way     = way;
    1618                 r_icache_miss_set     = set;
    1619 
    1620                 if ( cleanup )
     1620        r_icache.read_select(r_icache_vci_paddr.read(),
     1621                             &victim,
     1622                             &way,
     1623                             &set,
     1624                             &found,
     1625                             &cleanup );
     1626        if ( not found )
     1627        {
     1628            break;
     1629        }
     1630        else
     1631        {
     1632            r_icache_miss_way     = way;
     1633            r_icache_miss_set     = set;
     1634
     1635            if ( cleanup )
     1636            {
     1637                if ( not r_icache_cc_send_req.read() )
    16211638                {
    1622                     r_icache_fsm           = ICACHE_MISS_CLEAN;
    1623                     r_icache_miss_clack    = true;
    1624                     // request cleanup
    1625                     r_icache_cc_send_req   = true;
    1626                     r_icache_cc_send_nline = victim;
    1627                     r_icache_cc_send_way   = way;
    1628                     r_icache_cc_send_type  = CC_TYPE_CLEANUP;
     1639                    r_icache_cc_send_req    = true;
     1640                    r_icache_cc_send_nline  = victim;
     1641                    r_icache_cc_send_way    = way;
     1642                    r_icache_cc_send_type   = CC_TYPE_CLEANUP;   
    16291643                }
    16301644                else
    16311645                {
    1632                     r_icache_fsm          = ICACHE_MISS_WAIT;
     1646                    r_icache_cleanup_victim_req   = true;
     1647                    r_icache_cleanup_victim_nline = victim;
    16331648                }
     1649
     1650                r_icache_miss_clack           = true;
     1651                r_icache_fsm                  = ICACHE_MISS_CLEAN;
     1652            }
     1653            else
     1654            {
     1655                r_icache_fsm          = ICACHE_MISS_WAIT;
     1656            }
    16341657
    16351658#if DEBUG_ICACHE
    … …  
    16441667}
    16451668#endif
    1646             }
    16471669        }
    16481670        break;
    … …  
    16771699        if (m_ireq.valid) m_cost_ins_miss_frz++;
    16781700
     1701        // send cleanup victim request
     1702        if ( r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read() )
     1703        {
     1704            r_icache_cc_send_req        = true;
     1705            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
     1706            r_icache_cc_send_way        = r_icache_miss_way;
     1707            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
     1708            r_icache_cleanup_victim_req = false;
     1709        }   
     1710
    16791711        // coherence clack interrupt
    16801712        if ( r_icache_clack_req.read() )
    … …  
    16841716            break;
    16851717        }
    1686 
     1718       
    16871719        // coherence interrupt
    1688         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1720        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read() )
    16891721        {
    16901722            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    17561788        if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    17571789
     1790        // send cleanup victim request
     1791        if ( r_icache_cleanup_victim_req.read() and not r_icache_cc_send_req.read() )
     1792        {
     1793            r_icache_cc_send_req        = true;
     1794            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
     1795            r_icache_cc_send_way        = r_icache_miss_way;
     1796            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
     1797            r_icache_cleanup_victim_req = false;
     1798        }   
     1799
    17581800        // coherence clack interrupt
    17591801        if ( r_icache_clack_req.read() )
    … …  
    17651807
    17661808        // coherence interrupt
    1767         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1809        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read() )
    17681810        {
    17691811            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    18441886
    18451887        // coherence interrupt
    1846         if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() )
     1888        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    18471889        {
    18481890            r_icache_fsm = ICACHE_CC_CHECK;
    … …  
    19231965            break;
    19241966        }
     1967       
     1968        assert ( not r_icache_cc_send_req.read() and "CC_SEND must be available in ICACHE_CC_CHECK");
    19251969
    19261970        // Match between MISS address and CC address
    … …  
    19612005#endif
    19622006        }
    1963 
    1964 
    1965         assert ( not r_icache_cc_send_req.read() and "CC_SEND must be available in ICACHE_CC_CHECK");
    19662007
    19672008        // CC request handler
    … …  
    31073148
    31083149        // coherence request (from CC_RECEIVE FSM)
    3109         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     3150        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    31103151        {
    31113152            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    34143455
    34153456        // coherence request (from CC_RECEIVE FSM)
    3416         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     3457        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    34173458        {
    34183459            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    37213762
    37223763        // coherence request (from CC_RECEIVE FSM)
    3723         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     3764        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    37243765        {
    37253766            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38003841
    38013842        // coherence request (from CC_RECEIVE FSM)
    3802         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     3843        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38033844        {
    38043845            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38303871
    38313872        // coherence request (from CC_RECEIVE FSM)
    3832         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     3873        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38333874        {
    38343875            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    38733914
    38743915        // coherence request (from CC_RECEIVE FSM)
    3875         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     3916        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38763917        {
    38773918            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    39714012                              &set,
    39724013                              &word);
     4014
     4015        /*if (m_proc_id == 1) { std::cout << "rdata XTN_FLUSH_DATA = " << std::hex << rdata << std::dec << " | at cycle = " << m_cpt_total_cycles << std::endl; }
     4016        if (m_proc_id == 1) { r_cc_send_data_fifo.print(); }*/
     4017
    39734018        if(r_cc_send_data_fifo.wok())
    39744019        {
    … …  
    40474092        {
    40484093            paddr = (paddr_t)r_dcache_save_wdata.read();
     4094            if (vci_param::N > 32)
     4095                paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
    40494096            hit   = true;
    40504097        }
    … …  
    42334280                              &set,
    42344281                              &word);
     4282
     4283        /*if (m_proc_id == 1) { std::cout << "rdata XTN_INVAL_DATA = " << std::hex << rdata << std::dec << " | at cycle = " << m_cpt_total_cycles << std::endl; }
     4284        if (m_proc_id == 1) { r_cc_send_data_fifo.print(); }*/
     4285
    42354286        if(r_cc_send_data_fifo.wok())
    42364287        {
    … …  
    42634314    }
    42644315    ////////////////////////
    4265     case DCACHE_MISS_SELECT:   // Try to select a slot in associative set
    4266                                // if previous cleanup has been sent.
    4267                                // Waiting in this state if no slot available
    4268                                // Set the r_dcache_cleanup_req flip-flop
    4269                                // and the r_dcache_miss_clack flip-flop
    4270                                // when a cleanup is required
     4316    case DCACHE_MISS_SELECT:       // Try to select a slot in associative set,
     4317                                   // Waiting in this state if no slot available.
     4318                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
     4319                                   // we send the cleanup request in this state.
     4320                                   // If not, a r_icache_cleanup_victim_req flip-flop is
     4321                                   // utilized for saving this cleanup request, and it will be sent later
     4322                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
     4323                                   // The r_icache_miss_clack flip-flop is set
     4324                                   // when a cleanup is required
    42714325    {
    42724326        if ( m_dreq.valid) m_cost_data_miss_frz++;
    … …  
    42814335
    42824336        // coherence request (from CC_RECEIVE FSM)
    4283         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     4337        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    42844338        {
    42854339            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    42884342        }
    42894343
    4290         if ( not r_dcache_cc_send_req.read() ) // blocked until previous cc_send request is sent
    4291         {
    4292             bool     found = false;
    4293             bool     cleanup = false;
    4294             size_t   way = 0;
    4295             size_t   set = 0;
    4296             paddr_t  victim = 0;
     4344        bool     found = false;
     4345        bool     cleanup = false;
     4346        bool     dirty = false;
     4347        bool     ncc = false;
     4348        size_t   way = 0;
     4349        size_t   set = 0;
     4350        paddr_t  victim = 0;
    42974351            int state;
    42984352
    … …  
    43004354m_cpt_dcache_dir_read++;
    43014355#endif
    4302             r_dcache.read_select( r_dcache_save_paddr.read(),
    4303                                   &victim,
    4304                                   &way,
    4305                                   &set,
    4306                                   &found,
    4307                                   &cleanup );
     4356        r_dcache.read_select( r_dcache_save_paddr.read(),
     4357                              &victim,
     4358                              &way,
     4359                              &set,
     4360                              &found,
     4361                              &cleanup );
    43084362            state = r_dcache.get_cache_state(way,set);
    4309             if ( found )
    4310             {
    4311                 r_dcache_miss_way = way;
    4312                 r_dcache_miss_set = set;
    4313 
    4314                 if ( cleanup )
     4363        if (  not found )
     4364        {
     4365            break;
     4366        }
     4367        else
     4368        {
     4369            r_dcache_miss_way = way;
     4370            r_dcache_miss_set = set;
     4371
     4372            if ( cleanup )
     4373            {
     4374
     4375                r_dcache_miss_clack           = true;
     4376                r_dcache_fsm                  = DCACHE_MISS_CLEAN;
     4377
     4378               
     4379                if( (state == CACHE_SLOT_STATE_VALID_NCC) )
    43154380                {
    4316                     r_dcache_miss_clack   = true;
    4317                     r_dcache_fsm          = DCACHE_MISS_CLEAN;
    4318                     // request cleanup
    4319                     r_dcache_cc_send_req   = true;
    4320                     r_dcache_cc_send_nline = victim;
    4321                     r_dcache_cc_send_way   = way;
    4322                     r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
    4323                    
    4324                     if( (state == CACHE_SLOT_STATE_VALID_NCC) )
     4381                    //r_dcache_cleanup_ncc = true;
     4382                    ncc = true;
     4383                    r_dcache_cleanup_will_ncc = true;
     4384
     4385                    /*ODCCP*/ // if line is dirty we must save the data values
     4386                    if (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_DIRTY)
    43254387                    {
    4326                         r_dcache_cleanup_ncc = true;
    4327                        
    4328                         /*ODCCP*/ // if line is dirty we must save the data values
    4329                         if (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_DIRTY)
     4388                        //r_dcache_cc_cleanup_updt_data = true;
     4389                        dirty = true;
     4390                        r_dcache_cleanup_will_contains_data = true;
     4391                        r_dcache_miss_data_addr = (victim*m_dcache_words)*4;
     4392                        r_dcache_fsm = DCACHE_MISS_DATA;
     4393
     4394                        /*TEST*/
     4395                        /*if (not r_dcache_cc_send_req.read())
     4396                            r_miss_cleanup_ncc_pending = true;
     4397                        else
     4398                            r_miss_cleanup_ncc_pending = false;*/
     4399
     4400                        m_cpt_data_cleanup_dirty ++;
     4401
     4402                        /*STATS DIRTY*/
     4403                        for (size_t w = 0; w < m_dcache_words; w++)
    43304404                        {
    4331                             r_dcache_cc_cleanup_updt_data = true;
    4332                             r_dcache_miss_data_addr = (victim*m_dcache_words)*4;
    4333                             r_dcache_fsm = DCACHE_MISS_DATA;
    4334                             m_cpt_data_cleanup_dirty ++;
    4335 
    4336                             /*STATS DIRTY*/
    4337                             for (size_t w = 0; w < m_dcache_words; w++)
    4338                             {
    4339                                 if(dirty_stats[(way * m_dcache_sets + set) * m_dcache_words + w] == true)
    4340                                     m_cpt_words_dirty++;
    4341                             }
     4405                            if(dirty_stats[(way * m_dcache_sets + set) * m_dcache_words + w] == true)
     4406                                m_cpt_words_dirty++;
    43424407                        }
    4343                         else
    4344                         {
    4345                             r_dcache_cc_cleanup_updt_data = false;
    4346                         }
    4347                     }
     4408                    }
    43484409                    else
    43494410                    {
    4350                         r_dcache_cc_cleanup_updt_data = false;
    4351                         r_dcache_cleanup_ncc = false;
     4411                        //r_dcache_cc_cleanup_updt_data = false;
     4412                        r_dcache_cleanup_will_contains_data = false;
    43524413                    }
     4414                }
     4415                else
     4416                {
     4417                    r_dcache_cleanup_will_contains_data = false;
     4418                    r_dcache_cleanup_will_ncc = false;
     4419                    //r_dcache_cc_cleanup_updt_data = false;
     4420                    //r_dcache_cleanup_ncc = false;
     4421                }
     4422
     4423                if ( not r_dcache_cc_send_req.read() )
     4424                {
     4425                    if (dirty) r_dcache_cc_cleanup_updt_data = true;
     4426                    else       r_dcache_cc_cleanup_updt_data = false;
     4427
     4428                    if (ncc)   r_dcache_cleanup_ncc = true;
     4429                    else       r_dcache_cleanup_ncc = false;
     4430
     4431                    r_dcache_cc_send_req    = true;
     4432                    r_dcache_cc_send_nline  = victim;
     4433                    r_dcache_cc_send_way    = way;
     4434                    r_dcache_cc_send_type   = CC_TYPE_CLEANUP;   
    43534435                }
    43544436                else
    43554437                {
    4356                     r_dcache_fsm          = DCACHE_MISS_WAIT;
     4438                    r_dcache_cleanup_victim_req   = true;
     4439                    r_dcache_cleanup_victim_nline = victim;
    43574440                }
     4441            }
     4442            else
     4443            {
     4444                r_dcache_fsm          = DCACHE_MISS_WAIT;
     4445            }
    43584446
    43594447#if DEBUG_DCACHE
    … …  
    43694457}
    43704458#endif
    4371             } // end found
    4372         }
     4459        } // end found
    43734460        break;
    43744461    }
    … …  
    43854472                              &set,
    43864473                              &word);
     4474
     4475        /*if (m_proc_id == 1) { std::cout << "rdata MISS_DATA = " << std::hex << rdata << std::dec << " | at cycle = " << m_cpt_total_cycles << std::endl; }
     4476        if (m_proc_id == 1) { r_cc_send_data_fifo.print(); }*/
    43874477
    43884478        if(r_cc_send_data_fifo.wok())
    … …  
    44664556        if ( m_dreq.valid) m_cost_data_miss_frz++;
    44674557
     4558        // send cleanup victim request
     4559        if ( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
     4560        {
     4561            r_dcache_cc_send_req        = true;
     4562            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline;
     4563            r_dcache_cc_send_way        = r_dcache_miss_way;
     4564            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
     4565            r_dcache_cleanup_victim_req = false;
     4566            if (r_dcache_cleanup_will_contains_data.read() == true)
     4567                r_dcache_cc_cleanup_updt_data = true;
     4568            else
     4569                r_dcache_cc_cleanup_updt_data = false;
     4570                   
     4571            if (r_dcache_cleanup_will_ncc.read())   r_dcache_cleanup_ncc = true;
     4572            else                                    r_dcache_cleanup_ncc = false;
     4573        }   
     4574
    44684575        // coherence clack request (from DSPIN CLACK)
    44694576        if ( r_dcache_clack_req.read() )
    … …  
    44754582
    44764583        // coherence request (from CC_RECEIVE FSM)
    4477         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     4584        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() and not r_dcache_cleanup_victim_req.read() /*and not r_miss_cleanup_ncc_pending.read()*/)
    44784585        {
    44794586            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    45894696        if ( m_dreq.valid) m_cost_data_miss_frz++;
    45904697
     4698        // send cleanup victim request
     4699        if ( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
     4700        {
     4701            r_dcache_cc_send_req        = true;
     4702            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline;
     4703            r_dcache_cc_send_way        = r_dcache_miss_way;
     4704            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
     4705            r_dcache_cleanup_victim_req = false;
     4706            if (r_dcache_cleanup_will_contains_data.read()) r_dcache_cc_cleanup_updt_data = true;
     4707            else                                            r_dcache_cc_cleanup_updt_data = false;
     4708           
     4709            if (r_dcache_cleanup_will_ncc.read())           r_dcache_cleanup_ncc = true;
     4710            else                                            r_dcache_cleanup_ncc = false;
     4711        }   
     4712
    45914713        // coherence clack request (from DSPIN CLACK)
    45924714        if ( r_dcache_clack_req.read() )
    … …  
    45984720
    45994721        // coherence request (from CC_RECEIVE FSM)
    4600         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     4722        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() and not r_dcache_cleanup_victim_req.read() /*and not r_miss_cleanup_ncc_pending.read()*/)
    46014723        {
    46024724            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    47124834
    47134835        // coherence request (from CC_RECEIVE FSM)
    4714         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     4836        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    47154837        {
    47164838            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    47574879
    47584880        // coherence request (from CC_RECEIVE FSM)
    4759         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     4881        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    47604882        {
    47614883            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    48114933
    48124934        // coherence request (from CC_RECEIVE FSM)
    4813         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     4935        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    48144936        {
    48154937            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    49115033
    49125034        // coherence request (from CC_RECEIVE FSM)
    4913         if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() )
     5035        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    49145036        {
    49155037            r_dcache_fsm = DCACHE_CC_CHECK;
    … …  
    50105132        }
    50115133
    5012        
     5134        assert ( not r_dcache_cc_send_req.read() and "CC_SEND must be available in DCACHE_CC_CHECK" );
     5135
    50135136        // Match between MISS address and CC address
    5014         // note: In the same cycle we can handle a CLACK and a MISS match
    5015         // because the CLACK access the directory but the MISS match dont.
    50165137        if (r_cc_receive_dcache_req.read() and
    50175138          ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT  )  or
    … …  
    50495170#endif
    50505171        }
    5051 
    5052 
    5053         assert ( not r_dcache_cc_send_req.read() and "CC_SEND must be available in DCACHE_CC_CHECK");
    50545172
    50555173        // CC request handler
    … …  
    52365354                              &set,
    52375355                              &word);
     5356       
     5357        /*if (m_proc_id == 1) { std::cout << "rdata CC_INVAL_DATA = " << std::hex << rdata << std::dec << " | at cycle = " << m_cpt_total_cycles << std::endl; }
     5358        if (m_proc_id == 1) { r_cc_send_data_fifo.print(); }*/
     5359       
    52385360        if(r_cc_send_data_fifo.wok())
    52395361        {
     5362           
    52405363            r_dcache_cc_inval_addr = r_dcache_cc_inval_addr.read() + 4;
    52415364
    … …  
    52585381                        << " / WAY = " << way
    52595382                        << " / SET = " << set << std::endl;
     5383                    r_dcache.printTrace();
    52605384                }
    52615385#endif
    … …  
    60056129                        r_dcache_cc_send_req = false;
    60066130                        r_dcache_cc_cleanup_updt_data = false;
     6131                        //r_miss_cleanup_ncc_pending = false;
    60076132                        r_cc_send_cpt_word = 0;
    60086133                        r_cc_send_fsm = CC_SEND_IDLE;
    … …  
    60956220            // flip_flop to check that ?
    60966221            if (not (r_cc_receive_icache_req.read()) and
    6097                 not (r_cc_receive_dcache_req.read()) and 
     6222                not (r_cc_receive_dcache_req.read()) and
    60986223                (p_dspin_m2p.write.read()))
    60996224            {
    … …  
    61356260            uint64_t receive_data = p_dspin_m2p.data.read();
    61366261            // for data INVAL, wait for dcache to take the request
    6137             if (p_dspin_m2p.write.read() and not r_cc_receive_dcache_req.read())
     6262            if (p_dspin_m2p.write.read()           and
     6263                not r_cc_receive_dcache_req.read() )
    61386264            {
    61396265                // request dcache to handle the INVAL
    … …  
    61536279            uint64_t receive_data = p_dspin_m2p.data.read();
    61546280            // for ins INVAL, wait for icache to take the request
    6155             if (p_dspin_m2p.write.read() and not r_cc_receive_icache_req.read())
     6281            if (p_dspin_m2p.write.read()           and
     6282                not r_cc_receive_icache_req.read() )
    61566283            {
    61576284                // request icache to handle the INVAL
    … …  
    62036330            // for data INVAL, wait for dcache to take the request and fifo to
    62046331            // be empty
    6205             if ( r_cc_receive_updt_fifo_be.empty() and 
     6332            if ( r_cc_receive_updt_fifo_be.empty() and
    62066333                 p_dspin_m2p.write.read() )
    62076334            {
    … …  
    62236350            // for ins INVAL, wait for icache to take the request and fifo to be
    62246351            // empty
    6225             if ( r_cc_receive_updt_fifo_be.empty() and 
     6352            if ( r_cc_receive_updt_fifo_be.empty() and
    62266353                 p_dspin_m2p.write.read() )
    62276354            {
Note: See TracChangeset for help on using the changeset viewer.