Ignore:
Timestamp:
Feb 27, 2014, 12:32:14 PM (8 years ago)
Author:
devigne
Message:

Invalidation from memcache on a non-coherent line can cause a cleanup_data.
While sending this cleanup the processor can do a write on the same line.
However there is no guarantee that the memcache will receive transactions in
the correct order, ie it can handle writing before cleanup and therefore
overwrite the new value of writing that is more current than the data contained
in the cleanup.
To solve this problem we have block writes to ZOMBIE lines, they are unlocked
when the line becomes EMPTY.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r615 r645  
    441441    //r_dcache_in_tlb        = new bool[dcache_ways*dcache_sets];
    442442    //r_dcache_contains_ptd  = new bool[dcache_ways*dcache_sets];
    443     r_dcache_content_state = new int [dcache_ways*dcache_sets];
    444     r_dcache_dirty_word    = new int [dcache_ways*dcache_sets*dcache_words];
     443    r_dcache_content_state = new int  [dcache_ways*dcache_sets];
     444    r_dcache_dirty_word    = new int  [dcache_ways*dcache_sets*dcache_words];
     445    r_dcache_zombi_ncc     = new bool [dcache_ways*dcache_sets];
    445446    ///////////////////////////////////////////////////////////
    446447
     
    474475    delete [] r_dcache_content_state;
    475476    delete [] r_dcache_dirty_word;
     477    delete [] r_dcache_zombi_ncc;
    476478    /////////////////////////////////
     479    print_stats();
    477480}
    478481
     
    642645        << "- DUNC TRANSACTION        = " << m_cpt_dunc_transaction << std::endl
    643646        << "- LL TRANSACTION          = " << m_cpt_ll_transaction << std::endl
     647        << "- WRITE DATA MISS         = " << m_cpt_data_write_miss << std::endl
     648        << "- WRITE DATA ON ZOMBI     = " << m_cpt_data_write_on_zombi << std::endl
     649        << "- WRITE DATA ON ZOMBI NCC = " << m_cpt_data_write_on_zombi_ncc << std::endl
    644650        << "- CLEANUP DATA NOT DIRTY  = " << m_cpt_cleanup_data_not_dirty << std::endl
    645651        << "- CLEANUP DATA DIRTY WORD = " << m_cpt_cleanup_data_dirty_word << std::endl;
     
    743749    m_cpt_cleanup_data_not_dirty  = 0;
    744750    m_cpt_cleanup_data_dirty_word = 0;
     751    m_cpt_data_write_miss = 0;
     752    m_cpt_data_write_on_zombi = 0;
     753    m_cpt_data_write_on_zombi_ncc = 0;
    745754
    746755}
     
    778787            //r_dcache_contains_ptd[i]  = false;
    779788            r_dcache_content_state[i] = LINE_CACHE_DATA_NOT_DIRTY;
    780             r_dcache_dirty_word[i] = 0;
     789            r_dcache_dirty_word[i]    = 0;
     790            r_dcache_zombi_ncc[i]     = false;
    781791        }
    782792
     
    943953        m_cpt_cleanup_data_not_dirty  = 0;
    944954        m_cpt_cleanup_data_dirty_word = 0;
     955        m_cpt_data_write_miss = 0;
     956        m_cpt_data_write_on_zombi = 0;
     957        m_cpt_data_write_on_zombi_ncc = 0;
    945958
    946959        m_cpt_itlbmiss_transaction      = 0;
     
    22932306
    22942307
    2295         // physical address computation : systematic DTLB access if activated)
     2308        // physical address computation : systematic DTLB access (if activated)
    22962309        if ( m_dreq.valid )
    22972310        {
    2298 
    22992311
    23002312            if ( r_mmu_mode.read() & DATA_TLB_MASK )  // DTLB activated
     
    29302942                            // response to processor
    29312943                            m_drsp.valid        = true;
     2944
     2945
    29322946                            // activating P1 stage
    2933                             if( (cache_state != CACHE_SLOT_STATE_ZOMBI )&&(cache_state != CACHE_SLOT_STATE_EMPTY )&&(cacheable) )
     2947                            if( (cache_state != CACHE_SLOT_STATE_ZOMBI) && (cache_state != CACHE_SLOT_STATE_EMPTY) && (cacheable) )
    29342948                            {
    29352949                                wbuf_request = (cache_state == CACHE_SLOT_STATE_VALID_CC); //write to L2 only if CC
    29362950                                updt_request = true;
    2937                                 if (cache_state == CACHE_SLOT_STATE_VALID_NCC)
     2951                                if ( cache_state == CACHE_SLOT_STATE_VALID_NCC )
    29382952                                {
    2939                                     if (r_dcache_content_state[cache_way*m_dcache_sets+cache_set] == LINE_CACHE_DATA_NOT_DIRTY)
     2953                                    if ( r_dcache_content_state[cache_way*m_dcache_sets+cache_set] == LINE_CACHE_DATA_NOT_DIRTY )
    29402954                                    {
    29412955                                        r_dcache_content_state[cache_way*m_dcache_sets+cache_set] = LINE_CACHE_DATA_DIRTY;
    29422956                                    }
    2943                                     r_dcache_dirty_word[(cache_way*m_dcache_sets +cache_set)*m_dcache_words+cache_word] = 1;//dirty bit with word granularity (only for stats)
     2957                                    //dirty bit with word granularity (only for stats)
     2958                                    r_dcache_dirty_word[(cache_way*m_dcache_sets +cache_set)*m_dcache_words+cache_word] = 1;
    29442959                                    m_cpt_data_write_back ++;
    29452960                                }
    29462961                            }
     2962                            // We stall proc if a write request is on line ZOMBI
     2963                            // Invalidation from memcache on a non-coherent
     2964                            // line can cause cleanup_data. While sending this
     2965                            // cleanup the processor can do a write on the same
     2966                            // line. However there is no guarantee that the
     2967                            // memcache will receive transactions in the
     2968                            // correct order, ie it can handle writing before
     2969                            // cleanup and therefore overwrite the new value of
     2970                            // writing that is more current than the data
     2971                            // contained in the cleanup .
     2972                            // TODO : MAYBE NEED TO OPTIMIZE
     2973                            else if ( cache_state == CACHE_SLOT_STATE_ZOMBI )
     2974                            {
     2975                                m_drsp.valid = false;
     2976                                r_dcache_fsm = DCACHE_IDLE;
     2977                                // STAT : WRITE ON ZOMBI NCC LINE
     2978                                if (r_dcache_zombi_ncc[cache_way*m_dcache_sets+cache_set] == true)
     2979                                {
     2980                                    m_cpt_data_write_on_zombi_ncc++;
     2981                                }
     2982
     2983                                m_cpt_data_write_on_zombi++;
     2984                            }
    29472985                            else
    29482986                            {
     2987                               if ( cacheable ) m_cpt_data_write_miss++;
     2988                               
    29492989                               wbuf_request = true;
    29502990                               updt_request = false;
     
    40864126m_cpt_dcache_dir_write++;
    40874127#endif
     4128
     4129
     4130
    40884131        r_dcache.write_dir( way,
    40894132                            set,
     
    48184861
    48194862                    r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_NOT_DIRTY;
     4863
    48204864                }
    48214865                else
     
    48304874                        r_dcache_dirty_word[(way*m_dcache_sets +set)*m_dcache_words+word] = 0;
    48314875                    }
     4876
     4877                    // STAT : WRITE ON ZOMBI NCC LINE
     4878                    r_dcache_zombi_ncc[r_dcache_miss_way.read()*m_dcache_sets+r_dcache_miss_set.read()] = true;
    48324879                }
    48334880
     
    51875234                                r_dcache_clack_set.read(),
    51885235                                CACHE_SLOT_STATE_EMPTY);
     5236
     5237            // STAT : WRITE ON ZOMBI NCC LINE
     5238            r_dcache_zombi_ncc[r_dcache_clack_way.read()*m_dcache_sets+r_dcache_clack_set.read()] = false;
    51895239
    51905240            if ( (r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
Note: See TracChangeset for help on using the changeset viewer.