Changeset 254


Ignore:
Timestamp:
Aug 16, 2012, 7:32:45 PM (12 years ago)
Author:
alain
Message:

Two modifications:
1/ fixing a bug in the DCACHE_CC_INVAL state, related
to the TLB invalidation procedure (the nline was not properly defined).
2/ simplifiing the DCACHE_DIRTY_SC_WAIT state behaviour, as suggested by Hao:
we still wait for the SC response, but we just return to IDLE state
without analysing the response (no difference between success of failure,
because the work is done by the coherence transaction...)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r253 r254  
    4343        "ICACHE_XTN_CACHE_FLUSH",
    4444        "ICACHE_XTN_TLB_INVAL", 
    45         "ICACHE_XTN_CACHE_INVAL_VA",
     45        "ICACHE_XTN_CACHE_INVAL_VA",
    4646        "ICACHE_XTN_CACHE_INVAL_PA",
    4747        "ICACHE_XTN_CACHE_INVAL_GO",
    … …  
    6666        "DCACHE_TLB_MISS",
    6767        "DCACHE_TLB_PTE1_GET",
    68         "DCACHE_TLB_PTE1_SELECT", 
     68        "DCACHE_TLB_PTE1_SELECT", 
    6969        "DCACHE_TLB_PTE1_UPDT",
    7070        "DCACHE_TLB_PTE2_GET",
    71         "DCACHE_TLB_PTE2_SELECT",
     71        "DCACHE_TLB_PTE2_SELECT",
    7272        "DCACHE_TLB_PTE2_UPDT",   
    7373        "DCACHE_TLB_LR_UPDT",
    … …  
    742742        // Debug variables
    743743        m_debug_previous_hit      = false;
    744         m_idebug_previous_hit      = false;
    745         m_debug_dcache_fsm        = false;
    746         m_debug_icache_fsm        = false;
     744        m_idebug_previous_hit     = false;
     745        m_debug_dcache_fsm            = false;
     746        m_debug_icache_fsm            = false;
    747747        m_debug_cleanup_fsm       = false;
    748748
    … …  
    757757        m_cpt_icache_dir_write  = 0;
    758758
    759         m_cpt_frz_cycles        = 0;
    760         m_cpt_total_cycles      = 0;
    761         m_cpt_stop_simulation   = 0;
     759        m_cpt_frz_cycles        = 0;
     760        m_cpt_total_cycles      = 0;
     761        m_cpt_stop_simulation   = 0;
    762762
    763763        m_cpt_data_miss         = 0;
    … …  
    782782        m_cost_unc_transaction        = 0;
    783783        m_cost_write_transaction      = 0;
    784         m_cost_icache_unc_transaction = 0;
     784        m_cost_icache_unc_transaction = 0;
    785785        m_length_write_transaction    = 0;
    786786
    … …  
    811811        m_cost_data_tlb_inval_frz = 0;         
    812812
    813         m_cpt_cc_broadcast   = 0;
    814 
    815         m_cost_updt_data_frz  = 0;
    816         m_cost_inval_ins_frz  = 0;
    817         m_cost_inval_data_frz = 0;
    818         m_cost_broadcast_frz  = 0;
    819 
    820         m_cpt_cc_cleanup_data = 0;
    821         m_cpt_cc_cleanup_ins  = 0;
     813        m_cpt_cc_broadcast   = 0;
     814
     815            m_cost_updt_data_frz  = 0;
     816            m_cost_inval_ins_frz  = 0;
     817            m_cost_inval_data_frz = 0;
     818            m_cost_broadcast_frz  = 0;
     819
     820            m_cpt_cc_cleanup_data = 0;
     821            m_cpt_cc_cleanup_ins  = 0;
    822822
    823823        m_cpt_itlbmiss_transaction      = 0;   
    … …  
    960960            r_tgt_pktid = p_vci_tgt_c.pktid.read();
    961961
    962             if (sizeof(paddr_t) <= 32) {
    963                 assert(p_vci_tgt_c.be.read() == 0 && "byte enable should be 0 for 32bits paddr");
    964                 r_tgt_paddr  =
    965                         (paddr_t)p_vci_tgt_c.wdata.read() * m_dcache_words * 4;
    966             } else {
    967                 r_tgt_paddr  = (paddr_t)(p_vci_tgt_c.be.read() & 0x3) << 32 |
    968                         (paddr_t)p_vci_tgt_c.wdata.read() * m_dcache_words * 4;
     962            if (sizeof(paddr_t) <= 32)
     963        {
     964                     assert(p_vci_tgt_c.be.read() == 0
     965             && "byte enable should be 0 for 32bits paddr");
     966             r_tgt_paddr  = (paddr_t)p_vci_tgt_c.wdata.read() * m_dcache_words * 4;
     967            }
     968        else
     969        {
     970             r_tgt_paddr  = (paddr_t)(p_vci_tgt_c.be.read() & 0x3) << 32 |
     971                                        (paddr_t)p_vci_tgt_c.wdata.read() * m_dcache_words * 4;
    969972            }
    970973
    … …  
    20272030            {
    20282031                tlb_inval_required       = true;
    2029                 r_dcache_tlb_inval_count = 0;
    2030                 r_dcache_tlb_inval_line  = r_dcache_p1_paddr.read()>>
     2032                    r_dcache_tlb_inval_count = 0;
     2033                    r_dcache_tlb_inval_line  = r_dcache_p1_paddr.read()>>
    20312034                                             (uint32_log2(m_dcache_words<<2));
    2032                 r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     2035                    r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    20332036            }
    20342037            else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
    … …  
    20362039                r_itlb.reset();
    20372040                r_dtlb.reset();
    2038                 r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     2041                    r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    20392042            }
    20402043
    … …  
    32953298    }
    32963299    ////////////////////////
    3297     case DCACHE_TLB_LR_WAIT:            // Waiting a response to SC transaction.
    3298                                         // We consume the response in rsp FIFO,
    3299                                         // and exit the sub-fsm, but we don't
    3300                                         // analyse the response, because we don't
    3301                                         // care if the L/R bit update is not done.
    3302                                         // We must take the coherence requests because
    3303                                         // there is a risk of dead-lock
     3300    case DCACHE_TLB_LR_WAIT:            // Waiting the response to SC transaction.
     3301                                    // We consume the response in rsp FIFO,
     3302                                    // and exit the sub-fsm, but we don't
     3303                                    // analyse the response, because we don't
     3304                                    // care if the L/R bit update is not done.
     3305                                    // We must take the coherence requests because
     3306                                    // there is a risk of dead-lock
    33043307
    33053308    {
    … …  
    35443547    ////////////////////////////
    35453548    case DCACHE_XTN_DC_INVAL_GO:  // In this state, we invalidate the cache line
    3546                                   // Blocked if previous cleanup not completed
     3549                                              // Blocked if previous cleanup not completed
    35473550                                  // Test if itlb or dtlb inval is required   
    35483551    {
    3549         if ( not r_dcache_cleanup_req.read() )
    3550         {
     3552        if ( not r_dcache_cleanup_req.read() )
     3553        {
    35513554            paddr_t     nline;
    35523555            size_t      way        = r_dcache_xtn_way.read();
    35533556            size_t      set        = r_dcache_xtn_set.read();
    3554             bool hit;
     3557            bool    hit;
    35553558   
    35563559            hit = r_dcache.inval( way,
    35573560                                  set,
    35583561                                  &nline );
    3559             assert(hit && "XTN_DC_INVAL way/set should still be in cache");
     3562            assert(hit && "XTN_DC_INVAL way/set should still be in cache");
    35603563
    35613564            // request cleanup
    3562             r_dcache_cleanup_req  = true;
    3563             r_dcache_cleanup_line = nline;
     3565            r_dcache_cleanup_req  = true;
     3566            r_dcache_cleanup_line = nline;
    35643567           
    35653568            // possible itlb & dtlb invalidate
    35663569            if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
    35673570            {
    3568                 r_dcache_tlb_inval_line  = nline;
    3569                 r_dcache_tlb_inval_count = 0;
     3571                r_dcache_tlb_inval_line  = nline;
     3572                r_dcache_tlb_inval_count = 0;
    35703573                r_dcache_fsm_scan_save   = DCACHE_XTN_DC_INVAL_END;
    35713574                r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    3572                 r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    3573             }
     3575                r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     3576            }
    35743577            else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
    35753578            {
    35763579                r_itlb.reset();
    35773580                r_dtlb.reset();
    3578                 r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     3581                r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    35793582                r_dcache_fsm = DCACHE_IDLE;
    35803583                m_drsp.valid = true;
    … …  
    36553658        size_t  way        = r_dcache_miss_way.read();
    36563659        size_t  set        = r_dcache_miss_set.read();
    3657         bool hit;
     3660        bool    hit;
    36583661
    36593662        hit = r_dcache.inval( way,
    … …  
    36613664                        &nline );
    36623665
    3663         assert(hit && "selected way/set line should be in dcache");
     3666        assert(hit && "selected way/set line should be in dcache");
    36643667
    36653668#if DEBUG_DCACHE
    … …  
    36863689            r_itlb.reset();
    36873690            r_dtlb.reset();
    3688             r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     3691            r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    36893692            r_dcache_fsm = DCACHE_MISS_WAIT;
    36903693        }
    … …  
    39373940            vci_rsp_fifo_dcache_get = true;     
    39383941            m_drsp.valid            = true;
    3939             m_drsp.rdata            = r_vci_rsp_fifo_dcache.read();
     3942            m_drsp.rdata            = r_vci_rsp_fifo_dcache.read();
    39403943            r_dcache_fsm            = DCACHE_IDLE;
    39413944        }       
    … …  
    39443947    //////////////////////////
    39453948    case DCACHE_DIRTY_GET_PTE:          // This sub_fsm set the PTE Dirty bit in memory
    3946                                         // before handling a processor WRITE or SC request 
    3947                                         // Input argument is r_dcache_dirty_paddr
    3948                                         // In this first state, we get PTE value in dcache
    3949                                         // and post a SC request to CMD FSM
     3949                                    // before handling a processor WRITE or SC request 
     3950                                    // Input argument is r_dcache_dirty_paddr
     3951                                    // In this first state, we get PTE value in dcache
     3952                                    // and post a SC request to CMD FSM
    39503953    {
    39513954        // get PTE in dcache
    … …  
    40094012        {
    40104013            vci_rsp_fifo_dcache_get = true;
    4011             if ( r_vci_rsp_fifo_dcache.read() == 0 )    // exit if dirty bit update atomic
    4012             {
    4013                 r_dcache_fsm = DCACHE_IDLE;
     4014            r_dcache_fsm            = DCACHE_IDLE;
    40144015
    40154016#if DEBUG_DCACHE
    40164017if ( m_debug_dcache_fsm )
    40174018{
    4018     std::cout << "  <PROC " << name() << ".DCACHE_DIRTY_SC_WAIT> Dirty bit successfully set"
    4019               << std::endl;
     4019    std::cout << "  <PROC " << name() << ".DCACHE_DIRTY_SC_WAIT> SC completed" << std::endl;
    40204020}
    40214021#endif
    4022             }
    4023             else                                        // invalidate the cache line TLBs
    4024             {
    4025 
    4026 #if DEBUG_DCACHE
    4027 if ( m_debug_dcache_fsm )
    4028 {
    4029     std::cout << "  <PROC " << name() << ".DCACHE_DIRTY_SC_WAIT> PTE modified : Inval cache line & TLBs"
    4030               << std::endl;
    4031 }
    4032 #endif
    4033                 paddr_t nline;
    4034                 size_t  way = r_dcache_dirty_way.read();
    4035                 size_t  set = r_dcache_dirty_set.read();
    4036                 bool hit;
    4037 
    4038                 hit = r_dcache.inval( way,
    4039                                       set,
    4040                                       &nline );
    4041 
    4042                 assert(hit && "PTE should still be in dcache");
    4043 
    4044                 // request cleanup
    4045                 r_dcache_cleanup_req  = true;
    4046                 r_dcache_cleanup_line = nline;
    4047 
    4048                 if ( r_dcache_in_tlb[way*m_dcache_sets+set] )           // contains PTE
    4049                 {
    4050                     r_dcache_tlb_inval_line  = nline;
    4051                     r_dcache_tlb_inval_count = 0;
    4052                     r_dcache_fsm_scan_save   = DCACHE_IDLE;
    4053                     r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    4054                     r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4055                 } 
    4056                 else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] ) // contains PTD
    4057                 {
    4058                     r_itlb.reset();
    4059                     r_dtlb.reset();
    4060                     r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    4061                     r_dcache_fsm = DCACHE_IDLE;
    4062                 }
    4063                 else
    4064                 {
    4065                     r_dcache_fsm = DCACHE_IDLE;
    4066                 }
    4067             }
    40684022        }
    40694023        break;
    … …  
    40994053 
    41004054        }
    4101         else                                                            // no match
    4102         {
    4103             uint32_t    rdata;
    4104             size_t      way;
    4105             size_t      set;
    4106             size_t      word;
    4107 
    4108             bool        hit = r_dcache.read(paddr,
    4109                                             &rdata,     // unused
     4055        else                                                    // no match for a pending miss
     4056            {
     4057            uint32_t   rdata;
     4058            size_t         way;
     4059            size_t         set;
     4060            size_t         word;
     4061
     4062            bool           hit = r_dcache.read( paddr,
     4063                                            &rdata,     // unused
    41104064                                            &way,
    41114065                                            &set,
    … …  
    41554109    }
    41564110    /////////////////////
    4157     case DCACHE_CC_INVAL:       // invalidate one cache line
    4158                                 // and test possible copies in TLBs
    4159     {
    4160         paddr_t nline;
    4161         size_t  way        = r_dcache_cc_way.read();
    4162         size_t  set        = r_dcache_cc_set.read();
    4163         bool hit;
     4111    case DCACHE_CC_INVAL:       // invalidate one cache line after
     4112                                // invalidation of copies in TLBs
     4113    {
     4114        paddr_t  nline;
     4115        size_t   way    = r_dcache_cc_way.read();
     4116        size_t   set    = r_dcache_cc_set.read();
     4117        bool    hit;
    41644118
    41654119        if ( r_dcache_in_tlb[way*m_dcache_sets+set] )                   // selective TLB inval
    41664120        {
    41674121            r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4168             r_dcache_tlb_inval_line  = nline;
     4122            r_dcache_tlb_inval_line  = r_tgt_paddr.read() >> (uint32_log2(m_dcache_words)+2);
    41694123            r_dcache_tlb_inval_count = 0;
    41704124            r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    41714125            r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    41724126        }
    4173         else                                                            // actual cache line inval
     4127        else                                                                              // actual cache line inval
    41744128        {
    41754129            if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )         // TLB flush
    … …  
    41954149#endif
    41964150 
    4197             assert(hit && "CC_INVAL way/set should still be in dcache");
     4151            assert(hit && "CC_INVAL way/set should be in dcache");
    41984152        }
    41994153        break;
Note: See TracChangeset for help on using the changeset viewer.