Ignore:
Timestamp:
Aug 25, 2014, 5:58:16 PM (8 years ago)
Author:
devigne
Message:

RWT commit :

  • Merge with trunk.
  • Cosmetic
  • Bugfix in state WRITE_IVT_LOCK_HIT_WB.

MemCache? records invalidation in IVT in this state but we do not check that
the IVT was full. Thus invalidation was issued without actually recorded in the
query IVT ...

  • Bugfix :

When a NCC line owned by a L1 cache with srcid != 0 was removed from MemCache?,
the owner field was reset to 0. If this same L1 cache was sending a read to
retrieve this line the MemCache? sent this line on CC mode.

  • Bugfix :

The MemCache? reset the 'inst' field to 0 when solving a
invalidation due to a change of state of line (NCC to CC).
But a line can be NCC (ie contained in a DATA cache) then asked by INST cache,
this read triggers a transition NCC to CC but we must save the nature of this read.
Now this information is stored in a register (r_read_to_cleanup_inst).

  • Add a counter for the number of minimum inputs available

in the heap. This counter indicates whether the heap size of 4096 is relevant.

Location:
branches/RWT/modules/vci_cc_vcache_wrapper/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r646 r767  
    280280    };
    281281
    282 //    enum transaction_type_d_e
    283 //    {
    284 //        // b0 : 1 if cached
    285 //        // b1 : 1 if instruction
    286 //        TYPE_DATA_UNC     = 0x0,
    287 //        TYPE_DATA_MISS    = 0x1,
    288 //        TYPE_INS_UNC      = 0x2,
    289 //        TYPE_INS_MISS     = 0x3,
    290 //    };
    291 
    292     //////////////////MODIFIED////////////////
     282
     283    // cache line status
    293284    enum content_line_cache_status_e
    294285    {
     
    522513    sc_signal<size_t>       r_dcache_cc_send_updt_tab_idx;  // DCACHE cc_send update table index
    523514   
    524     // special registers for ODCCP/RWT
    525     sc_signal<bool>         r_dcache_cc_cleanup_updt_data;          // Register for cleanup with data (wb updt)
    526     sc_signal<bool>         r_dcache_cc_cleanup_line_ncc;          // Register for cleanup with data (wb updt)
    527     sc_signal<bool>         r_dcache_miss_victim_no_coherence;      // Register for victim in no coherence mode
    528     sc_signal<bool>         r_dcache_line_no_coherence;             // Register for line current in no coherence mode
     515    // special registers for RWT
     516    sc_signal<bool>         r_dcache_cc_cleanup_updt_data;     // Register for cleanup with data (wb updt)
     517    sc_signal<bool>         r_dcache_cc_cleanup_line_ncc;      // Register for cleanup with data (wb updt)
     518    sc_signal<bool>         r_dcache_miss_victim_no_coherence; // Register for victim in no coherence mode
     519    sc_signal<bool>         r_dcache_line_no_coherence;        // Register for line current in no coherence mode
    529520    sc_signal<bool>         r_dcache_dirty_save;             
    530521    sc_signal<uint32_t>     r_cc_send_cpt_word;
     
    536527    sc_signal<paddr_t>      r_dcache_xtn_data_addr;
    537528    sc_signal<uint32_t>     r_dcache_xtn_data_cpt;
     529    sc_signal<bool>         r_dcache_read_state;
     530
    538531    // dcache directory extension
    539     ///////////////////////////MODIFIED///////////////////////////////////////////////////
    540     //bool                    *r_dcache_in_tlb;           // copy exist in dtlb or itlb
    541     //bool                    *r_dcache_contains_ptd;     // cache line contains a PTD
    542532    int                     *r_dcache_content_state; // content state of one cache line
    543     int                     *r_dcache_dirty_word;   
    544     bool                    *r_dcache_zombi_ncc;     
     533    // Stats
     534    int                     *r_dcache_dirty_word;    // use for compute number of words dirty per cleanup_data
     535    bool                    *r_dcache_zombi_ncc;     // use for compute number of blocked write on ncc zombi line
    545536    //////////////////////////////////////////////////////////////////////////////////////
    546537
    547     //RWT
    548     sc_signal<bool>         r_dcache_read_state;
    549    
    550      ///////////////////////////////////
     538    ///////////////////////////////////
    551539    // Physical address extension for data access
    552540    sc_signal<uint32_t>     r_dcache_paddr_ext;             // CP2 register (if vci_address > 32)
     
    574562    //RWT
    575563    GenericFifo<bool>       r_vci_rsp_fifo_rpktid;
    576 
    577564    GenericFifo<uint32_t>   r_cc_send_data_fifo;   
    578565
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r646 r767  
    346346      r_dcache_tlb_pte_flags("r_dcache_tlb_pte_flags"),
    347347      r_dcache_tlb_pte_ppn("r_dcache_tlb_pte_ppn"),
    348 //     r_dcache_tlb_cache_way("r_dcache_tlb_cache_way"),
    349 //     r_dcache_tlb_cache_set("r_dcache_tlb_cache_set"),
    350 //     r_dcache_tlb_cache_word("r_dcache_tlb_cache_word"),
    351348      r_dcache_tlb_way("r_dcache_tlb_way"),
    352349      r_dcache_tlb_set("r_dcache_tlb_set"),
     
    425422
    426423    assert( (itlb_sets == dtlb_sets) and
    427              "itlb_sets and dtlb_sets parameters must be etqual");
     424             "itlb_sets and dtlb_sets parameters must be equal");
    428425
    429426    assert( (itlb_ways == dtlb_ways) and
    430              "itlb_ways and dtlb_ways parameters must be etqual");
     427             "itlb_ways and dtlb_ways parameters must be equal");
    431428
    432429    r_mmu_params = (uint32_log2(m_dtlb_ways)   << 29)   | (uint32_log2(m_dtlb_sets)   << 25) |
     
    470467/////////////////////////////////////
    471468{
    472     ////////////MODIFIED/////////////
    473     //delete [] r_dcache_in_tlb;
    474     //delete [] r_dcache_contains_ptd;
    475469    delete [] r_dcache_content_state;
    476470    delete [] r_dcache_dirty_word;
    477471    delete [] r_dcache_zombi_ncc;
    478472    /////////////////////////////////
    479     print_stats();
     473    //print_stats();
    480474}
    481475
     
    783777        for (size_t i=0 ; i< m_dcache_ways*m_dcache_sets ; i++)
    784778        {
    785             // MODIFIED
    786             //r_dcache_in_tlb[i]        = false;
    787             //r_dcache_contains_ptd[i]  = false;
    788779            r_dcache_content_state[i] = LINE_CACHE_DATA_NOT_DIRTY;
    789780            r_dcache_dirty_word[i]    = 0;
     
    22462237    m_drsp.error = false;
    22472238    m_drsp.rdata = 0;
    2248     //if(m_cpt_total_cycles % 1000000 == 0 ) r_dcache.printTrace();
    22492239
    22502240    switch ( r_dcache_fsm.read() )
     
    23812371            size_t way = r_dcache_save_cache_way.read();
    23822372            size_t set = r_dcache_save_cache_set.read();
    2383             // MODIFIED
    2384             //if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
    2385             //{
     2373
    23862374            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    23872375            {
     
    23902378                    r_dcache_tlb_inval_line  = r_dcache_save_paddr.read()>>
    23912379                                           (uint32_log2(m_dcache_words<<2));
    2392                 // MODIFIED RWT: DIRTY
    2393                     //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     2380
    23942381                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    23952382            }
    2396             // MODIFIED
    2397             //else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
    2398             //{
    23992383            else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
    24002384            {
    24012385                r_itlb.reset();
    24022386                r_dtlb.reset();
    2403                 // MODIFIED
    2404                     //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     2387
    24052388                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    24062389            }
     
    28022785m_cpt_data_miss++;
    28032786#endif
    2804                                 /*ODCCP*/
    2805                                 //std::cout << "\t\t\t\t\tCACHE MISS NEED READ for : " << name() << std::endl;
    28062787                                // request a VCI DMISS transaction
    28072788                                r_dcache_vci_paddr    = paddr;
     
    28322813m_cpt_data_read++;
    28332814#endif
    2834                                 /*if ((tlb_flags.s == 0) and (r_mmu_mode.read() & DATA_TLB_MASK) and (cache_state == CACHE_SLOT_STATE_VALID_CC))
    2835                                 {
    2836                                     //ODCCP
    2837                                     std::cout << "READ NO COHERENCE on " << name() << " | paddr = " << std::hex << paddr << std::dec << " | way = " << cache_way << " | set = " << cache_set << " | at cycle : "<< m_cpt_total_cycles << std::endl;
    2838                                     r_dcache.write_dir(cache_way,
    2839                                                        cache_set,
    2840                                                        CACHE_SLOT_STATE_VALID_NCC);
    2841                                 }*/
    28422815                                // returns data to processor
    28432816                                m_drsp.valid   = true;
     
    28832856                        r_dcache_ll_rsp_count = 0;
    28842857                        r_dcache_fsm          = DCACHE_LL_WAIT;
    2885                         /*ODCCP*/
    2886                         //std::cout << "LL on " << name() << " | paddr = " << std::hex << paddr << std::dec << " | at cycle : " << m_cpt_total_cycles << std::endl;
    28872858
    28882859                    }// end LL
     
    29732944                                m_cpt_data_write_on_zombi++;
    29742945                            }
    2975                             else
     2946                            else // Miss in DCACHE
    29762947                            {
    2977                                m_cpt_data_write_miss++;
    2978                                
    2979                                m_drsp.valid = true;
    2980                                wbuf_request = true;
    2981                                updt_request = false;
     2948                                m_drsp.valid = true;
     2949                                wbuf_request = true;
     2950                                updt_request = false;
     2951                                m_cpt_data_write_miss++;
    29822952                            }
    29832953                        }
     
    31553125                       &word,
    31563126                       &cache_state );
     3127
    31573128#ifdef INSTRUMENTATION
    31583129m_cpt_dcache_data_read++;
    31593130m_cpt_dcache_dir_read++;
    31603131#endif
    3161         /*ODCCP*/
    3162 //        assert((cache_state != CACHE_SLOT_STATE_VALID_NCC) and "DCACHE_TLB_PTE1_GET : IMPOSSIBLE NCC HERE");
    3163 //        if ( cache_state == CACHE_SLOT_STATE_VALID_CC )   // hit in dcache
     3132
    31643133        if (( cache_state == CACHE_SLOT_STATE_VALID_NCC ) or ( cache_state == CACHE_SLOT_STATE_VALID_CC ))
    31653134        {
     
    31993168            {
    32003169                // mark the cache line ac containing a PTD
    3201                 //MODIFIED
    3202                 //r_dcache_contains_ptd[m_dcache_sets*way+set] = true;
    32033170                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_CONTAINS_PTD;
    32043171
     
    32363203            else                        //  PTE1 :  we must update the TLB
    32373204            {
    3238                 // MODIFIED
    3239                 //r_dcache_in_tlb[m_icache_sets*way+set] = true;
    32403205                r_dcache_content_state[m_icache_sets*way+set] = LINE_CACHE_IN_TLB;
    32413206                r_dcache_tlb_pte_flags  = entry;
    3242                //r_dcache_tlb_cache_way  = way;
    3243                //r_dcache_tlb_cache_set  = set;
    3244                //r_dcache_tlb_cache_word = word;
    32453207                r_dcache_fsm            = DCACHE_TLB_PTE1_SELECT;
    32463208
     
    34793441m_cpt_dcache_dir_read++;
    34803442#endif
    3481         /*ODCCP*/
    3482 //        assert((cache_state != CACHE_SLOT_STATE_VALID_NCC) and "DCACHE_TLB_PTE2_GET : IMPOSSIBLE NCC HERE");
    3483 //        if (cache_state == CACHE_SLOT_STATE_VALID_CC)    // hit in dcache
    34843443        if ((cache_state == CACHE_SLOT_STATE_VALID_CC) or (cache_state == CACHE_SLOT_STATE_VALID_NCC))
    34853444        {
     
    35143473            else                                // mapped : we must update the TLB
    35153474            {
    3516                 // MODIFIED
    3517                 //r_dcache_in_tlb[m_dcache_sets*way+set] = true;
    35183475                r_dcache_content_state[m_dcache_sets*way+set] = LINE_CACHE_IN_TLB;
    35193476                r_dcache_tlb_pte_flags  = pte_flags;
    35203477                r_dcache_tlb_pte_ppn    = pte_ppn;
    3521                //r_dcache_tlb_cache_way  = way;
    3522                //r_dcache_tlb_cache_set  = set;
    3523                //r_dcache_tlb_cache_word = word;
    35243478                r_dcache_fsm            = DCACHE_TLB_PTE2_SELECT;
    35253479
     
    40023956                               &tag,
    40033957                               &state );
    4004             /*ODCCP*/
    40053958
    40063959            if ( state == CACHE_SLOT_STATE_VALID_CC )         // inval required
     
    40313984                r_dcache_miss_set     = set;
    40323985                r_dcache_cc_cleanup_line_ncc = true;
     3986
    40333987                if (r_dcache_content_state[m_dcache_sets*way+set] != LINE_CACHE_DATA_NOT_DIRTY)//Must send data in the cleanup
    4034                 //if (true)//Must send data in the cleanup
    40353988                {
    40363989                    r_dcache_xtn_flush_addr_data = (tag * m_dcache_sets + set) * m_dcache_words * 4;
     
    40924045            }
    40934046        }
    4094 //       else if ( r_dcache_clack_req.read() )
    4095 //       {
    4096 //           r_dcache_fsm = DCACHE_CC_CHECK;
    4097 //           r_dcache_fsm_cc_save = r_dcache_fsm.read();
    4098 //           break;
    4099 //       }
    41004047        break;
    41014048    }
     
    41094056        size_t set = r_dcache_miss_set.read();
    41104057
    4111         // MODIFIED
    4112         //r_dcache_in_tlb[m_dcache_sets*way+set]       = false;
    4113         //r_dcache_contains_ptd[m_dcache_sets*way+set] = false;
    41144058        r_dcache_content_state[m_dcache_sets*way+set]  = LINE_CACHE_DATA_DIRTY;
    41154059
     
    42154159                           &set,
    42164160                           &word );
    4217         /*ODCCP*/
    4218         //assert((state != CACHE_SLOT_STATE_VALID_NCC) and "NOT YET DONE");
     4161
    42194162        if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))      // inval to be done
    42204163        {
     
    42664209m_cpt_dcache_dir_write++;
    42674210#endif
    4268             // MODIFIER POUR DIRTY BIT //
     4211
    42694212            if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))// request cleanup
    42704213            {
     
    42844227                    r_dcache_cc_cleanup_line_ncc = true;
    42854228                    if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY)) //must send data
    4286                     //if (true) //must send data
    42874229                    {
    42884230                        r_dcache_cc_cleanup_updt_data = true;
     
    43054247                }
    43064248            }
    4307             /*ODCCP*/
    43084249
    43094250            // possible itlb & dtlb invalidate
    4310             // MODIFIED
    4311             //if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
    4312             //{
    43134251            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    43144252            {
     
    43174255                r_dcache_fsm_scan_save  = DCACHE_XTN_DC_INVAL_END;
    43184256                r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
    4319                 // MODIFIED
    4320                 //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    43214257                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    43224258            }
    4323             // MODIFIED
    4324             //else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
    4325             //{
    43264259            else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD)
    43274260            {
    43284261                r_itlb.reset();
    43294262                r_dtlb.reset();
    4330                 // MODIFIED
    4331                 //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    43324263                r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    43334264                r_dcache_fsm = DCACHE_IDLE;
     
    43544285    /*ODCCP*/
    43554286    //////////////////////////////
    4356     case DCACHE_XTN_DC_INVAL_DATA:      //A verifier
     4287    case DCACHE_XTN_DC_INVAL_DATA:
    43574288    {
    43584289
     
    44204351        }
    44214352
    4422             bool     found = false;
    4423             bool     cleanup = false;
    4424             size_t   way = 0;
    4425             size_t   set = 0;
    4426             paddr_t  victim = 0;
    4427             int state;
    4428             bool     s_cleanup_updt_data = false;
    4429             bool     s_cleanup_line_ncc = false;
     4353            bool    found = false;
     4354            bool    cleanup = false;
     4355            size_t  way = 0;
     4356            size_t  set = 0;
     4357            paddr_t victim = 0;
     4358            int     state;
     4359            bool    s_cleanup_updt_data = false;
     4360            bool    s_cleanup_line_ncc = false;
    44304361
    44314362#ifdef INSTRUMENTATION
     
    44494380                    r_dcache_miss_clack   = true;
    44504381                    r_dcache_fsm          = DCACHE_MISS_CLEAN;
    4451                     if( (state == CACHE_SLOT_STATE_VALID_NCC) )//and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_DIRTY) )
     4382                    if( (state == CACHE_SLOT_STATE_VALID_NCC) )
    44524383                    {
    4453                         //MODIFIER POUR DIRTY BIT //
    44544384                        s_cleanup_line_ncc = true;
    44554385                        r_dcache_miss_data_addr = (victim*m_dcache_words)*4;
    44564386                        if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY))//must send data
    4457                         //if (true)//must send data
    44584387                        {
    44594388                            s_cleanup_updt_data = true;
     
    44724401                            m_cpt_cleanup_data_not_dirty ++;
    44734402                    }
    4474                        
    44754403                    else
    44764404                    {
     
    45554483            }
    45564484        }
    4557 //       else if ( r_dcache_clack_req.read() )
    4558 //       {
    4559 //           r_dcache_fsm = DCACHE_CC_CHECK;
    4560 //           r_dcache_fsm_cc_save = r_dcache_fsm.read();
    4561 //           break;
    4562 //       }
    45634485
    45644486        break;
     
    45904512        // if selective itlb & dtlb invalidate are required
    45914513        // the miss response is not handled before invalidate completed
    4592         // MODIFIED
    4593         //if ( r_dcache_in_tlb[way*m_dcache_sets+set] )
    4594         //{
    45954514        if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    45964515        {
    4597             //MODIFIED
    4598             //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    45994516            r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    46004517            if( not r_dcache_cleanup_victim_req.read() )
     
    46104527            r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    46114528        }
    4612         // MODIFIED
    4613         //else if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )
    4614         //{
    46154529        else if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_CONTAINS_PTD )
    46164530        {
    46174531            r_itlb.reset();
    46184532            r_dtlb.reset();
    4619             // MODIFIED
    4620             //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    46214533            r_dcache_content_state[way*m_dcache_sets+set] = LINE_CACHE_DATA_DIRTY;
    46224534            r_dcache_fsm = DCACHE_MISS_WAIT;
     
    48464758                if (r_dcache_read_state.read())
    48474759                {
    4848                   r_dcache.write_dir( r_dcache_save_paddr.read(),
     4760                    r_dcache.write_dir( r_dcache_save_paddr.read(),
    48494761                                        r_dcache_miss_way.read(),
    48504762                                        r_dcache_miss_set.read(),
     
    48564768                else
    48574769                {
    4858                   r_dcache.write_dir( r_dcache_save_paddr.read(),
     4770                    r_dcache.write_dir( r_dcache_save_paddr.read(),
    48594771                                        r_dcache_miss_way.read(),
    48604772                                        r_dcache_miss_set.read(),
     
    48784790          << " / SET = "   << r_dcache_miss_set.read() << std::endl;
    48794791#endif
    4880                 // reset directory extension
    4881 
    4882                 // MODIFIED
    4883                 //r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4884                 //r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    48854792            }
    48864793            if      (r_dcache_miss_type.read()==PTE1_MISS) r_dcache_fsm = DCACHE_TLB_PTE1_GET;
     
    51575064                           word,
    51585065                           r_dcache_vci_cas_new.read());
    5159             //std::cout << "CAS local" << std::endl;
     5066
    51605067            if ( r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_IN_TLB )
    51615068            {
     
    53175224        r_dcache_cc_way = way;
    53185225        r_dcache_cc_set = set;
    5319             /*RWT / ODCCP*/
    5320         if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))             // hit
    5321         {
    5322           // need to update the cache state
     5226
     5227        if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))  // hit
     5228        {
     5229            // need to update the cache state
    53235230            r_dcache_cc_need_write = true;
    53245231            r_dcache_cc_cleanup_line_ncc = false;
     
    54245331            }
    54255332        }
    5426             assert (not r_dcache_cc_send_req.read() &&
     5333        assert (not r_dcache_cc_send_req.read() &&
    54275334                    "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    54285335                    "must not be set");
    5429             // coherence request completed
    5430                 r_cc_receive_dcache_req = false;
    5431             // request multicast acknowledgement
    5432                 r_dcache_cc_send_req = true;
    5433                 r_dcache_cc_send_way = way;
    5434                 r_dcache_cc_send_nline = r_cc_receive_dcache_nline.read();
    5435                 r_dcache_cc_send_type = CC_TYPE_CLEANUP;
    5436                 // MODIFIER POUR DIRTY BIT //
    5437                 if (cache_state == CACHE_SLOT_STATE_VALID_NCC and not r_cc_receive_dcache_inval_is_config.read())
     5336        // coherence request completed
     5337        r_cc_receive_dcache_req = false;
     5338        // request multicast acknowledgement
     5339        r_dcache_cc_send_req = true;
     5340        r_dcache_cc_send_way = way;
     5341        r_dcache_cc_send_nline = r_cc_receive_dcache_nline.read();
     5342        r_dcache_cc_send_type = CC_TYPE_CLEANUP;
     5343
     5344        if (cache_state == CACHE_SLOT_STATE_VALID_NCC and not r_cc_receive_dcache_inval_is_config.read())
     5345        {
     5346            r_dcache_cc_cleanup_line_ncc = true;
     5347            if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY) or r_dcache_dirty_save.read() or dirty_save) //must send data
     5348            {
     5349                r_dcache_cc_cleanup_updt_data = true;
     5350                for (size_t w = 0; w< m_dcache_words; w++)
    54385351                {
    5439                     r_dcache_cc_cleanup_line_ncc = true;
    5440                     if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY) or r_dcache_dirty_save.read() or dirty_save) //must send data
    5441                     {
    5442                         r_dcache_cc_cleanup_updt_data = true;
    5443                         for (size_t w = 0; w< m_dcache_words; w++)
    5444                         {
    5445                             m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
    5446                         }
    5447 
    5448                         r_dcache_fsm          = DCACHE_CC_INVAL_DATA;
    5449                     }
    5450                     else
    5451                     {
    5452                         r_dcache.write_dir( way,
    5453                                             set,
    5454                                             CACHE_SLOT_STATE_ZOMBI );
     5352                    m_cpt_cleanup_data_dirty_word += r_dcache_dirty_word[(m_dcache_sets*way+set)*m_dcache_words + w];
     5353                }
     5354
     5355                r_dcache_fsm          = DCACHE_CC_INVAL_DATA;
     5356            }
     5357            else
     5358            {
     5359                r_dcache.write_dir( way,
     5360                                    set,
     5361                                    CACHE_SLOT_STATE_ZOMBI );
    54555362 
    5456                         r_dcache_cc_cleanup_updt_data = false;
    5457                         r_dcache_fsm = r_dcache_fsm_cc_save.read();
    5458                     }
    5459                 }
    5460                 else
    5461                 {
    5462                     r_dcache_cc_cleanup_updt_data = false;
    5463                     r_dcache_fsm = r_dcache_fsm_cc_save.read();
    5464                 }
     5363                r_dcache_cc_cleanup_updt_data = false;
     5364                r_dcache_fsm = r_dcache_fsm_cc_save.read();
     5365            }
     5366        }
     5367        else
     5368        {
     5369            r_dcache_cc_cleanup_updt_data = false;
     5370            r_dcache_fsm = r_dcache_fsm_cc_save.read();
     5371        }
    54655372
    54665373        break;
     
    62206127            if (p_dspin_p2m.read.read())
    62216128            {
    6222                 //std::cout << "CLEANUP send on line " << r_dcache_cc_send_nline.read() << std::endl;
     6129
    62236130                if(r_dcache_cc_cleanup_updt_data.read() and (r_cc_send_last_client.read() == 0))//dcache request with data
    6224                {
     6131                {
    62256132                    r_cc_send_fsm = CC_SEND_CLEANUP_DATA_UPDT;
    62266133                }
     
    62486155                if(r_cc_send_data_fifo.rok())
    62496156                {
    6250                     /*ODCCP*///std::cout<<"CLEANUP_DATA_UPDT" << std::endl;
    62516157                    m_cpt_data_cleanup++;
    62526158                    cleanup_data_updt_fifo_dcache_get = true;
     
    62546160                    if (r_cc_send_cpt_word.read() == m_dcache_words-1)
    62556161                    {
    6256                         //std::cout << "L1 paddr CLEANUP DATA | paddr = " << std::hex << (r_dcache_cc_send_nline.read()*m_dcache_words)*4 << std::dec << std::endl;
    6257                         /*ODCCP*/
    6258                         //std::cout << "CLEANUP with DATA finished by " << name() << std::endl;
    62596162                        r_dcache_cc_send_req = false;
    62606163                        r_dcache_cc_cleanup_updt_data = false;
     
    65836486                                 vci_rsp_fifo_dcache_put,
    65846487                                 vci_rsp_fifo_dcache_data);
    6585     //BUG pktid
     6488
    65866489    r_vci_rsp_fifo_rpktid.update(vci_rsp_fifo_rpktid_get,
    65876490                                 vci_rsp_fifo_rpktid_put,
     
    67986701        {
    67996702            // initialize dspin send data
    6800 //            DspinDhccpParam::dspin_set(dspin_send_data,
    6801 //                                       0,
    6802 //                                       DspinDhccpParam::P2M_EOP);
    68036703            DspinDhccpParam::dspin_set(dspin_send_data,
    68046704                                       m_cc_global_id,
     
    68926792        case CC_SEND_CLEANUP_DATA_UPDT:
    68936793        {
    6894             /*if (r_cc_send_cpt_word.read() == m_dcache_words-1)
    6895             {
    6896                 DspinDhccpParam::dspin_set(dspin_send_data,
    6897                                            1,
    6898                                            DspinDhccpParam::FROM_L1_EOP);
    6899             }
    6900             else
    6901             {
    6902                 DspinDhccpParam::dspin_set(dspin_send_data,
    6903                                            0,
    6904                                            DspinDhccpParam::FROM_L1_EOP);
    6905             }*/
    69066794
    69076795            DspinDhccpParam::dspin_set(dspin_send_data,
     
    69106798           
    69116799            p_dspin_p2m.data = dspin_send_data;
    6912             //std::cout << "genmoore CLEANUP DATA UPDT : dspin_send_data = " << std::hex << dspin_send_data << std::dec << std::endl;
    69136800            p_dspin_p2m.write = true;
    69146801            p_dspin_p2m.eop = (r_cc_send_cpt_word.read() == m_dcache_words-1);
     
    69196806        {
    69206807            // initialize dspin send data
    6921 //            DspinDhccpParam::dspin_set(dspin_send_data,
    6922 //                                       1,
    6923 //                                       DspinDhccpParam::P2M_EOP);
    69246808            DspinDhccpParam::dspin_set(dspin_send_data,
    69256809                                       0,
Note: See TracChangeset for help on using the changeset viewer.