Changeset 767


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
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/lib/generic_cache_tsar/include/generic_cache.h

    r477 r767  
    586586                      data_t    data)
    587587    {
    588        /**/ //std::cout << "write cache : way = "<<way<<" | set = "<<set<<" | word = "<<word<<" | data = "<<(uint32_t)data << std::endl;
    589588        cache_data(way, set, word) = data;
    590589        cache_set_lru(way, set);
  • 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,
  • branches/RWT/modules/vci_mem_cache/caba/source/include/update_tab.h

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r644 r767  
    8383        TGT_CMD_WRITE,
    8484        TGT_CMD_CAS,
    85         TGT_CMD_ERROR,
    86         TGT_CMD_CONFIG
     85        TGT_CMD_CONFIG,
     86        TGT_CMD_ERROR
    8787      };
    8888
     
    9696        TGT_RSP_MULTI_ACK_IDLE,
    9797        TGT_RSP_CLEANUP_IDLE,
     98        TGT_RSP_TGT_CMD_IDLE,
    9899        TGT_RSP_CONFIG_IDLE,
    99         TGT_RSP_TGT_CMD_IDLE,
    100100        TGT_RSP_READ,
    101101        TGT_RSP_WRITE,
     
    104104        TGT_RSP_MULTI_ACK,
    105105        TGT_RSP_CLEANUP,
    106         TGT_RSP_CONFIG,
    107         TGT_RSP_TGT_CMD
     106        TGT_RSP_TGT_CMD,
     107        TGT_RSP_CONFIG
    108108      };
    109109
     
    122122        CC_SEND_XRAM_RSP_IDLE,
    123123        CC_SEND_WRITE_IDLE,
     124        CC_SEND_READ_IDLE,
    124125        CC_SEND_CAS_IDLE,
    125126        CC_SEND_CONFIG_IDLE,
     
    437438      uint32_t     m_cpt_write_flits_remote; // number of flits for remote WRITEs
    438439      uint32_t     m_cpt_write_cost;     // Number of (flits * distance) for WRITEs
     440      uint32_t     m_cpt_write_ncc_miss;   // Number of write on ncc line
    439441
    440442      uint32_t     m_cpt_ll_local;       // Number of local LL transactions
     
    552554      uint32_t     m_cpt_xram_rsp_fsm_heap_used; // NB cycles HEAP LOCK used
    553555     
    554       uint32_t     m_cpt_heap_unused;            // NB cycles HEAP LOCK unused
     556      uint32_t     m_cpt_heap_unused;             // NB cycles HEAP LOCK unused
     557      uint32_t     m_cpt_heap_slot_available;     // NB HEAP slot available refresh at each cycles
     558      uint32_t     m_cpt_heap_min_slot_available; // NB HEAP : Min of slot available
    555559
    556560      //RWT
     
    584588      sc_in<bool>                                 p_clk;
    585589      sc_in<bool>                                 p_resetn;
    586       sc_in<bool>                                 p_irq;
     590      sc_out<bool>                                p_irq;
    587591      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
    588592      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
     
    618622          const soclib::common::IntTab       &srcid_x,        // global index RAM network
    619623          const soclib::common::IntTab       &tgtid_d,        // global index INT network
    620           const size_t                       cc_global_id,    // global index CC network
    621624          const size_t                       x_width,         // X width in platform
    622625          const size_t                       y_width,         // Y width in platform
     
    635638
    636639      void reset_counters();
    637       void print_stats(bool activity_counters, bool stats);
     640      void print_stats(bool activity_counters = true, bool stats = false);
    638641      void print_trace( size_t detailled = 0 );
    639642      void cache_monitor(addr_t addr);
     
    647650      void check_monitor(addr_t addr, data_t data, bool read);
    648651      uint32_t req_distance(uint32_t req_srcid);
     652      uint32_t min_value(uint32_t old_value, uint32_t new_value);
    649653      bool is_local_req(uint32_t req_srcid);
    650654      int  read_instrumentation(uint32_t regr, uint32_t & rdata);
     
    661665      const size_t                       m_sets;             // Number of cache sets
    662666      const size_t                       m_words;            // Number of words in a line
    663       const size_t                       m_cc_global_id;     // global_index on cc network
    664       const size_t                       m_xwidth;           // number of x bits in platform
    665       const size_t                       m_ywidth;           // number of y bits in platform
     667      size_t                             m_x_self;           // X self coordinate
     668      size_t                             m_y_self;           // Y self coordinate
     669      const size_t                       m_x_width;          // number of x bits in platform
     670      const size_t                       m_y_width;          // number of y bits in platform
    666671      size_t                             m_debug_start_cycle;
    667672      bool                               m_debug_ok;
     
    834839      sc_signal<addr_t>   r_read_to_cleanup_nline;  // cache line index
    835840      sc_signal<size_t>   r_read_to_cleanup_srcid;
     841      sc_signal<size_t>   r_read_to_cleanup_inst;
    836842      sc_signal<size_t>   r_read_to_cleanup_length;
    837843      sc_signal<size_t>   r_read_to_cleanup_first_word;
     
    10691075      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
    10701076      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
     1077      sc_signal<bool>     r_xram_rsp_rerror_irq;        // WRITE MISS rerror irq
     1078      sc_signal<bool>     r_xram_rsp_rerror_irq_enable; // WRITE MISS rerror irq enable
     1079      sc_signal<addr_t>   r_xram_rsp_rerror_address;    // WRITE MISS rerror address
     1080      sc_signal<size_t>   r_xram_rsp_rerror_rsrcid;     // WRITE MISS rerror srcid
    10711081
    10721082      // Buffer between XRAM_RSP fsm and TGT_RSP fsm  (response to L1 cache)
  • branches/RWT/modules/vci_mem_cache/caba/source/include/xram_transaction.h

    r495 r767  
    426426    void write_rsp(const size_t      index,
    427427                   const size_t      word,
    428                    const wide_data_t data)
     428                   const wide_data_t data,
     429                   const bool        rerror)
    429430    {
    430431        data_t  value;
     
    442443        assert( (tab[index].xram_read ) and
    443444        "MEMC ERROR: TRT entry is not a GET in TRT write_rsp()");
     445
     446        if ( rerror )
     447        {
     448            tab[index].rerror = true;
     449            return;
     450        }
    444451
    445452        // first 32 bits word
  • branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r646 r767  
    5656#define RANDOMIZE_CAS        1
    5757
     58// RWT configuration
     59#define REVERT_CC_MECANISM   0
     60
     61// Configuration
     62#define REVERT_BC_MECANISM   0
     63
    5864namespace soclib { namespace caba {
    5965
     
    6470        "TGT_CMD_WRITE",
    6571        "TGT_CMD_CAS",
    66         "TGT_CMD_ERROR",
    67         "TGT_CMD_CONFIG"
     72        "TGT_CMD_CONFIG",
     73        "TGT_CMD_ERROR"
    6874    };
    6975    const char *tgt_rsp_fsm_str[] =
     
    7581        "TGT_RSP_MULTI_ACK_IDLE",
    7682        "TGT_RSP_CLEANUP_IDLE",
     83        "TGT_RSP_TGT_CMD_IDLE",
    7784        "TGT_RSP_CONFIG_IDLE",
    78         "TGT_RSP_TGT_CMD_IDLE",
    7985        "TGT_RSP_READ",
    8086        "TGT_RSP_WRITE",
     
    8389        "TGT_RSP_MULTI_ACK",
    8490        "TGT_RSP_CLEANUP",
    85         "TGT_RSP_CONFIG",
    86         "TGT_RSP_TGT_CMD"
     91        "TGT_RSP_TGT_CMD",
     92        "TGT_RSP_CONFIG"
    8793    };
    8894    const char *cc_receive_fsm_str[] =
     
    97103        "CC_SEND_XRAM_RSP_IDLE",
    98104        "CC_SEND_WRITE_IDLE",
     105        "CC_SEND_READ_IDLE",
    99106        "CC_SEND_CAS_IDLE",
    100107        "CC_SEND_CONFIG_IDLE",
     
    353360            const IntTab        &srcid_x,          // global index on external network
    354361            const IntTab        &tgtid_d,          // global index on direct network
    355             const size_t        cc_global_id,      // global index on cc network
    356362            const size_t        x_width,           // number of x bits in platform
    357363            const size_t        y_width,           // number of x bits in platform
     
    378384        p_dspin_clack( "p_dspin_clack" ),
    379385
    380         m_seglist( mtp.getSegmentList(tgtid_d) ),
    381         m_nseg( 0 ),
    382         m_srcid_x( mtx.indexForId(srcid_x) ),
    383         m_initiators( 1 << vci_param_int::S ),
    384         m_heap_size( heap_size ),
    385         m_ways( nways ),
    386         m_sets( nsets ),
    387         m_words( nwords ),
    388         m_cc_global_id( cc_global_id ),
    389         m_xwidth(x_width),
    390         m_ywidth(y_width),
     386        m_seglist(mtp.getSegmentList(tgtid_d)),
     387        m_nseg(0),
     388        m_srcid_x( mtx.indexForId(srcid_x)),
     389        m_initiators(1 << vci_param_int::S),
     390        m_heap_size(heap_size),
     391        m_ways(nways),
     392        m_sets(nsets),
     393        m_words(nwords),
     394        m_x_width(x_width),
     395        m_y_width(y_width),
    391396        m_debug_start_cycle( debug_start_cycle ),
    392397        m_debug_ok( debug_ok ),
     
    547552            }
    548553
     554            assert( (m_nseg > 0) and
     555                    "MEMC ERROR : At least one segment must be mapped to this component");
     556
    549557            m_seg = new soclib::common::Segment*[m_nseg];
    550558
     
    555563                i++;
    556564            }
     565
     566            addr_t gid = m_seg[0]->baseAddress() >> (vci_param_int::N - x_width - y_width);
     567            m_x_self = (gid >> m_y_width) & ((1 << m_x_width) - 1);
     568            m_y_self =  gid               & ((1 << m_y_width) - 1);
    557569
    558570            // Allocation for IXR_RSP FSM
     
    664676    }
    665677
     678    /////////////////////////////////////////////////////
     679    tmpl(uint32_t)::min_value(uint32_t old_value, uint32_t new_value)
     680        /////////////////////////////////////////////////////
     681    {
     682        if (old_value < new_value)
     683            return old_value;
     684        else
     685            return new_value;
     686    }
    666687
    667688    /////////////////////////////////////////////////////
     
    670691    {
    671692        const uint32_t srcid_width = vci_param_int::S;
    672         uint8_t self_x_srcid = m_cc_global_id >> (srcid_width - m_xwidth);
    673         uint8_t self_y_srcid = (m_cc_global_id >> (srcid_width - m_ywidth)) & ((1 << m_xwidth) - 1);
    674 
    675         uint8_t x_srcid = req_srcid >> (srcid_width - m_xwidth);
    676         uint8_t y_srcid = (req_srcid >> (srcid_width - m_ywidth - m_xwidth)) & ((1 << m_xwidth) - 1);
    677         return abs(self_x_srcid - x_srcid) + abs(self_y_srcid - y_srcid);
     693
     694        uint8_t req_x = (req_srcid >> (srcid_width - m_x_width));
     695        uint8_t req_y = (req_srcid >> (srcid_width - m_x_width - m_y_width)) & ((1 << m_y_width) - 1);
     696
     697        return abs(m_x_self - req_x) + abs(m_y_self - req_y);
    678698    }
    679699
     
    865885        m_cpt_ncc_to_cc_write    = 0;
    866886        m_cpt_ncc_to_cc          = 0;
     887        m_cpt_write_ncc_miss     = 0;
    867888    }
    868889
    869890
    870891    /////////////////////////////////////////
    871     tmpl(void)::print_stats(bool activity_counters = true, bool stats = true)
     892    tmpl(void)::print_stats(bool activity_counters, bool stats)
    872893    {
    873894        std::cout << "**********************************" << std::dec << std::endl;
     
    891912                << "[008] WRITE FLITS REMOTE        = " << m_cpt_write_flits_remote << std::endl
    892913                << "[009] WRITE COST (FLITS * DIST) = " << m_cpt_write_cost << std::endl
     914                << "[XXX] WRITE L1 MISS NCC         = " << m_cpt_write_ncc_miss << std::endl
    893915                << std::endl
    894916                << "[010] LOCAL LL                  = " << m_cpt_ll_local << std::endl
     
    929951                << "[037] GET (UNIMPLEMENTED)       = " << m_cpt_get << std::endl
    930952                << "[038] WRITE BROADCAST           = " << m_cpt_write_broadcast << std::endl
     953                << "[039] MIN HEAP SLOT AVAILABLE   = " << m_cpt_heap_min_slot_available << std::endl
    931954                << std::endl
    932                 << "[039] CLEANUP DATA (FLITS)      = " << m_cpt_cleanup_data * 16 << std::endl
    933                 << "[040] NCC TO CC (READ)          = " << m_cpt_ncc_to_cc_read << std::endl
    934                 << "[041] NCC TO CC (WRITE)         = " << m_cpt_ncc_to_cc_write << std::endl
    935                 << "[042] NCC TO CC (TOTAL)         = " << m_cpt_ncc_to_cc << std::endl
     955                << "[040] CLEANUP DATA (FLITS)      = " << m_cpt_cleanup_data * 16 << std::endl
     956                << "[041] NCC TO CC (READ)          = " << m_cpt_ncc_to_cc_read << std::endl
     957                << "[042] NCC TO CC (WRITE)         = " << m_cpt_ncc_to_cc_write << std::endl
     958                << "[043] NCC TO CC (TOTAL)         = " << m_cpt_ncc_to_cc << std::endl
    936959                << std::endl;
    937960        }
     
    10171040        delete [] m_debug_previous_data;
    10181041        delete [] m_debug_data;
    1019 
    1020         print_stats();
    10211042    }
    10221043
     
    11371158            r_xram_rsp_to_ixr_cmd_req          = false;
    11381159            r_xram_rsp_trt_index               = 0;
     1160            r_xram_rsp_rerror_irq              = false;
     1161            r_xram_rsp_rerror_irq_enable       = false;
    11391162
    11401163            m_xram_rsp_to_cc_send_inst_fifo.init();
     
    11751198            m_cpt_write_flits_local  = 0;
    11761199            m_cpt_write_flits_remote = 0;
     1200            m_cpt_write_ncc_miss     = 0;
    11771201            m_cpt_write_cost         = 0;
    11781202            m_cpt_ll_local           = 0;
     
    12531277            m_cpt_ncc_to_cc_write         = 0;       
    12541278            m_cpt_ncc_to_cc               = 0;       
     1279
     1280            m_cpt_heap_min_slot_available = m_heap_size;
     1281            m_cpt_heap_slot_available     = m_heap_size;
     1282
    12551283            return;
    12561284        }
     
    13601388#endif
    13611389                    // checking segmentation violation
    1362                     addr_t      address  = p_vci_tgt.address.read();
    1363                     uint32_t    plen     = p_vci_tgt.plen.read();
    1364                     bool        found    = false;
    1365                     bool        config   = false;
    1366 
    1367                     for (size_t seg_id = 0; (seg_id < m_nseg) && !found; seg_id++)
     1390                    addr_t   address = p_vci_tgt.address.read();
     1391                    uint32_t plen    = p_vci_tgt.plen.read();
     1392                    bool     config  = false;
     1393
     1394                    for (size_t seg_id = 0; (seg_id < m_nseg) ; seg_id++)
    13681395                    {
    13691396                        if (m_seg[seg_id]->contains(address) &&
    13701397                                m_seg[seg_id]->contains(address + plen - vci_param_int::B) )
    13711398                        {
    1372                             found = true;
    13731399                            if ( m_seg[seg_id]->special() ) config = true;
    13741400                        }
    13751401                    }
    13761402
    1377                     if (!found)                /////////// out of segment error
    1378                     {
    1379                         r_tgt_cmd_fsm   = TGT_CMD_ERROR;
    1380                     }
    1381                     else if ( config )              /////////// configuration command
     1403                    if (config)                     /////////// configuration command
    13821404                    {
    13831405                        if (!p_vci_tgt.eop.read()) r_tgt_cmd_fsm = TGT_CMD_ERROR;
    1384                         else                            r_tgt_cmd_fsm = TGT_CMD_CONFIG;
     1406                        else                       r_tgt_cmd_fsm = TGT_CMD_CONFIG;
    13851407                    }
    13861408                    else                            //////////// memory access
     
    14041426                            // ==> TYPE_WRITE = X100 with the TSAR encoding
    14051427                            // ==> mask = 0b0111 = 0x7
    1406                             assert(((p_vci_tgt.pktid.read() & 0x7) == 0x4 or (p_vci_tgt.pktid.read() == 0x0)) and
     1428                            assert((((p_vci_tgt.pktid.read() & 0x7) == 0x4)  or ((p_vci_tgt.pktid.read() & 0x7) == 0x0)) and
    14071429                                    "The type specified in the pktid field is incompatible with the WRITE CMD");
    14081430                            r_tgt_cmd_fsm = TGT_CMD_WRITE;
     
    16201642                        }
    16211643
     1644                        // xram GET bus error registers
     1645                        case MEMC_RERROR:
     1646                        {
     1647                            need_rsp = true;
     1648                            error    = 0;
     1649
     1650                            if (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
     1651                            {
     1652                                switch (regr)
     1653                                {
     1654                                    case MEMC_RERROR_IRQ_ENABLE:
     1655                                        r_xram_rsp_rerror_irq_enable =
     1656                                            (p_vci_tgt.wdata.read() != 0);
     1657
     1658                                        break;
     1659                                       
     1660                                    default:
     1661                                        error = 1;
     1662                                        break;
     1663                                }
     1664                            }
     1665                            else if (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)
     1666                            {
     1667                                switch (regr)
     1668                                {
     1669                                    case MEMC_RERROR_SRCID:
     1670                                        rdata = (uint32_t)
     1671                                            r_xram_rsp_rerror_rsrcid.read();
     1672
     1673                                        break;
     1674
     1675                                    case MEMC_RERROR_ADDR_LO:
     1676                                        rdata = (uint32_t)
     1677                                            (r_xram_rsp_rerror_address.read()) &
     1678                                            ((1ULL<<32)-1);
     1679
     1680                                        break;
     1681
     1682                                    case MEMC_RERROR_ADDR_HI:
     1683                                        rdata = (uint32_t)
     1684                                            (r_xram_rsp_rerror_address.read() >> 32) &
     1685                                            ((1ULL<<32)-1);
     1686
     1687                                        break;
     1688
     1689                                    case MEMC_RERROR_IRQ_RESET:
     1690                                        if (not r_xram_rsp_rerror_irq.read()) break;
     1691
     1692                                        r_xram_rsp_rerror_irq = false;
     1693
     1694                                        break;
     1695
     1696                                    case MEMC_RERROR_IRQ_ENABLE:
     1697                                        rdata = (uint32_t)
     1698                                            (r_xram_rsp_rerror_irq_enable.read()) ? 1 : 0;
     1699
     1700                                        break;
     1701
     1702                                    default:
     1703                                        error = 1;
     1704                                        break;
     1705                                }
     1706                            }
     1707                            else
     1708                            {
     1709                                error = 1;
     1710                            }
     1711
     1712                            break;
     1713                        }
     1714
    16221715                        //unknown function
    16231716                        default:
     
    21002193        //   is signaled by the CLEANUP FSM by decrementing the r_config_rsp_lines counter.
    21012194        //   The CONFIG INVAL response is sent only when the last line has been invalidated.
     2195        //   There is no PUT transaction to XRAM, even if the invalidated line is dirty...
    21022196        //   TODO : The target buffer address must be aligned on a cache line boundary.
    21032197        //   This constraint can be released, but it requires to make 2 PUT transactions
     
    25592653                        r_config_heap_next = entry.next;
    25602654                        if ( last_copy ) r_config_fsm = CONFIG_HEAP_LAST;
     2655
     2656                        // <Activity counters>
     2657                        m_cpt_heap_slot_available++;
     2658                        // </Activity counters>
    25612659                    }
    25622660
     
    26842782                    {
    26852783                        r_read_ll_key   = m_llsc_table.ll(m_cmd_read_addr_fifo.read());
    2686                         /**//*std::cout << "MEMCACHE : from proc " << m_cmd_read_srcid_fifo.read()
    2687                               << " | @ " << std::hex << m_cmd_read_addr_fifo.read()
    2688                               << " | LL" << std::endl;*/
    26892784                        r_read_ll_done  = true;
    26902785                    }
     
    27082803                    {
    27092804                        r_read_coherent = entry.cache_coherent;
    2710                         if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read())) //hit on a WT line or the owner has no more copy (if LL, the owner must be invalidated even if he made the request)
     2805
     2806                        // hit on a WT line or the owner has no more copy (if LL, the owner must be invalidated even if he made the request)
     2807                        if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
    27112808                        {
    27122809                            // test if we need to register a new copy in the heap
     
    27172814                            else
    27182815                            {
    2719                                 //std::cout << "is LL = " << ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL) << std::endl;
    2720                                 //std::cout << "coherent = " << entry.cache_coherent << " | count = " << std::dec << entry.count << " | cached = " << cached_read << std::endl;
    27212816                                r_read_fsm = READ_HEAP_REQ;
    27222817                            }
     
    27552850                        size_t index;
    27562851                        addr_t nline = m_nline[(addr_t)(m_cmd_read_addr_fifo.read())];
    2757                         /*std::cout << "nline = " << std::dec <<  nline << std::endl
    2758                           << "inval en cours sur la ligne = " << m_upt.search_inval(nline, index) << std::endl
    2759                           << "UPT full = " << m_upt.is_full() << std::endl
    2760                           << "CC_SEND req = " << r_read_to_cc_send_req.read() << std::endl
    2761                           << "CLENAUP req = " <<r_read_to_cleanup_req.read() << std::endl;*/
    27622852                        if(m_ivt.search_inval(nline, index) or m_ivt.is_full() or r_read_to_cc_send_req.read() or r_read_to_cleanup_req.read()) //Check pending inval
    27632853                        {
     
    27822872                            r_read_to_cleanup_nline = nline;
    27832873                            r_read_to_cleanup_srcid = m_cmd_read_srcid_fifo.read();
     2874                            r_read_to_cleanup_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    27842875                            r_read_to_cleanup_length  = m_cmd_read_length_fifo.read();
    27852876                            r_read_to_cleanup_first_word = m_x[(addr_t) m_cmd_read_addr_fifo.read()];
     
    27882879                            r_read_to_cleanup_is_ll= ((m_cmd_read_pktid_fifo.read() & 0x7) == TYPE_LL);
    27892880                            r_read_to_cleanup_ll_key = r_read_ll_key.read();
    2790                             //std::cout << "cleanup req (read) on line " << nline << " /on proc " << r_read_copy.read() << std::endl;
    27912881
    27922882                            m_ivt.set(false,     // it's an inval transaction
     
    28072897                            {
    28082898                                std::cout
    2809                                     << "  <MEMC " << name() << " READ_IVT_LOCK>"
     2899                                    << "  <MEMC " << name() << " READ_IVT_LOCK>"
     2900                                    << std::hex
    28102901                                    << " Inval req on an NCC line"
     2902                                    << " | owner = " << r_read_copy.read()
     2903                                    << " | nline = " << nline
     2904                                    << std::dec
    28112905                                    << std::endl;
    28122906                            }
     
    28612955                    DirectoryEntry entry;
    28622956                    entry.valid   = true;
    2863                     entry.cache_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
    2864                     r_read_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
     2957                    //entry.cache_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
     2958                    //r_read_coherent = r_read_coherent.read() or inst_read or (!(cached_read)) or (r_read_copy.read() != m_cmd_read_srcid_fifo.read());
     2959
     2960                    entry.cache_coherent = r_read_coherent.read() or inst_read or (!(cached_read));
     2961                    r_read_coherent = r_read_coherent.read() or inst_read or (!(cached_read));
     2962
    28652963                    entry.is_cnt  = is_cnt;
    28662964                    entry.dirty   = r_read_dirty.read();
     
    29843082                        else            // switching to counter mode
    29853083                        {
    2986                             if(r_read_count.read() >1)              // heap must be cleared
     3084                            if(r_read_count.read() > 1)              // heap must be cleared
    29873085                            {
    29883086                                HeapEntry next_entry = m_heap.read(r_read_ptr.read());
     
    30433141                        m_heap.write_free_entry(heap_entry);
    30443142                        m_heap.write_free_ptr(r_read_next_ptr.read());
    3045                         if(r_read_last_free.read())  m_heap.set_full();
     3143
     3144                        if(r_read_last_free.read()) {
     3145                            m_heap.set_full();
     3146                        }
     3147                       
     3148                        // <Activity counters>
     3149                        m_cpt_heap_slot_available--;
     3150                        // </Activity counters>
    30463151
    30473152                        r_read_fsm = READ_RSP;
     
    31073212                        m_heap.write(r_read_ptr.read(),last_entry);
    31083213                        r_read_fsm = READ_RSP;
     3214
     3215                        // <Activity counters>
     3216                        m_cpt_heap_slot_available = m_cpt_heap_slot_available + (r_read_count.read() - 1);
     3217                        // </Activity counters>
    31093218                    }
    31103219                    else
     
    31253234                        r_read_to_tgt_rsp_length = m_cmd_read_length_fifo.read();
    31263235                        r_read_to_tgt_rsp_srcid  = m_cmd_read_srcid_fifo.read();
    3127                         /*RWT*/
    3128                         //BUG pktid
     3236
    31293237                        if (r_read_coherent.read())
    31303238                        {
    31313239                            r_read_to_tgt_rsp_pktid = 0x0 + m_cmd_read_pktid_fifo.read();
    3132                             //std::cout << "READ RSP COHERENT on word" << std::hex << m_x[(addr_t) m_cmd_read_addr_fifo.read()] << std::dec << std::endl;
    31333240                        }
    31343241                        else
     
    34423549                        r_write_coherent   = entry.cache_coherent;
    34433550
     3551                        if((entry.cache_coherent == false) and (entry.count != 0))
     3552                        {
     3553                            m_cpt_write_ncc_miss++;
     3554                        }
     3555
    34443556                        if (entry.cache_coherent or (entry.owner.srcid == r_write_srcid.read()) or (entry.count == 0)) // hit WT
    34453557                        {
     
    34623574                            {
    34633575                                r_write_fsm = WRITE_IVT_LOCK_HIT_WB;
    3464                                 //            if(r_write_pktid.read() == TYPE_SC)
    3465                                 //            {
    3466                                 //              r_write_sc_fail = true;
    3467                                 //            }
    34683576                            }
    34693577                        }
     
    35003608                        addr_t nline = m_nline[(addr_t)(r_write_address.read())];
    35013609
    3502                         //std::cout << "WRITE on NCC on line" << std::hex << nline << std::dec << std::endl;
    35033610                        //if there is a matched updt req, we should wait until it is over. Because
    35043611                        //we need the lastest updt data.
     
    35083615
    35093616                        if( not match_inval                          and
     3617                            not m_ivt.is_full()                      and
    35103618                            not r_write_to_cc_send_req.read()        and
    35113619                            not r_write_to_cc_send_multi_req.read()  and
     
    35333641                        if(m_debug)
    35343642                        {
    3535                             std::cout << "  <MEMC " << name() << " WRITE_IVT_LOCK_HIT_WB> get access to the UPT: "
     3643                            std::cout << "  <MEMC " << name() << " WRITE_IVT_LOCK_HIT_WB> get access to the IVT: "
    35363644                                << " Inval requested =  " << (not match_inval and not r_write_to_cc_send_req.read())
    35373645                                << std::endl;
     
    48084916                        r_ixr_rsp_trt_index = p_vci_ixr.rtrdid.read();
    48094917
    4810                         assert( ((p_vci_ixr.rerror.read() & 0x1) == 0) and
    4811                                 "MEMC ERROR in IXR_RSP state: XRAM response error !");
    4812 
    4813                         if(p_vci_ixr.reop.read())   // PUT
     4918                        if (p_vci_ixr.reop.read() and not
     4919                            p_vci_ixr.rerror.read())   // PUT
    48144920                        {
    48154921                            r_ixr_rsp_fsm = IXR_RSP_TRT_ERASE;
     
    48364942                }
    48374943
    4838                 ////////////////////////
    4839             case IXR_RSP_TRT_ERASE:   // erase the entry in the TRT
    4840                 // decrease the line counter if config request
     4944               ///////////////////////
     4945            case IXR_RSP_TRT_ERASE: // erase the entry in the TRT
     4946                                    // decrease the line counter if config request
    48414947                {
    48424948                    if(r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
     
    48464952                        {
    48474953                            config_rsp_lines_ixr_rsp_decr = true;
    4848                             m_trt.erase(index);
    4849                             r_ixr_rsp_fsm = IXR_RSP_IDLE;
    4850                         }
    4851                         else                            // not a config transaction
    4852                         {
    4853                             m_trt.erase(index);
    4854                             r_ixr_rsp_fsm = IXR_RSP_IDLE;
    4855                         }
     4954                        }
     4955                        m_trt.erase(index);
     4956                        r_ixr_rsp_fsm = IXR_RSP_IDLE;
    48564957
    48574958#if DEBUG_MEMC_IXR_RSP
     
    48724973                        bool        eop      = p_vci_ixr.reop.read();
    48734974                        wide_data_t data     = p_vci_ixr.rdata.read();
    4874                         bool        error    = ((p_vci_ixr.rerror.read() & 0x1) == 1);
    4875 
    4876                         assert(((eop == (word == (m_words-2))) or error) and
     4975                        bool        rerror   = ((p_vci_ixr.rerror.read() & 0x1) == 1);
     4976
     4977                        assert(((eop == (word == (m_words-2))) or rerror) and
    48774978                                "MEMC ERROR in IXR_RSP_TRT_READ state : invalid response from XRAM");
    48784979
    4879                         m_trt.write_rsp( index,
    4880                                 word,
    4881                                 data );
     4980                        m_trt.write_rsp( index, word, data, rerror );
    48824981
    48834982                        r_ixr_rsp_cpt = word + 2;
     
    50095108                    r_xram_rsp_victim_is_cnt    = victim.is_cnt;
    50105109                    r_xram_rsp_victim_inval     = inval ;
    5011                     r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1)); //a NCC line is by default considered as dirty in the L1: we must take a reservation on a TRT entry
    5012 
    5013                     if( not r_xram_rsp_trt_buf.rerror ) r_xram_rsp_fsm = XRAM_RSP_IVT_LOCK;
    5014                     else                                r_xram_rsp_fsm = XRAM_RSP_ERROR_ERASE;
     5110                    // a NCC line is by default considered as dirty in the L1: we must take a reservation on a TRT entry
     5111                    r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1));
     5112
     5113
     5114                    // A line that undergoes a change in its state (ncc to cc), should not be evicted from the memory cache.
     5115                    if((victim.tag * m_sets + set) == r_read_to_cleanup_nline.read() and r_read_to_cleanup_req.read())
     5116                    {
     5117                        r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     5118
     5119#if DEBUG_MEMC_XRAM_RSP
     5120                        if(m_debug)
     5121                            std::cout << "  <MEMC " << name() << " XRAM_RSP_TRT_COPY>"
     5122                                << " Victim line is in ncc to cc mecanism"
     5123                                << " / nline = " << std::hex << (victim.tag * m_sets + set)
     5124                                << std::endl;
     5125#endif
     5126                    }
     5127                    else if( not r_xram_rsp_trt_buf.rerror )
     5128                    {
     5129                        r_xram_rsp_fsm = XRAM_RSP_IVT_LOCK;
     5130                    }
     5131                    else
     5132                    {
     5133                        r_xram_rsp_fsm = XRAM_RSP_ERROR_ERASE;
     5134                    }
    50155135
    50165136#if DEBUG_MEMC_XRAM_RSP
     
    51955315#endif
    51965316
    5197                     // If the victim is not dirty (RWT: if it is not coherent, we can not know wether it is dirty or not), we don't need another XRAM  put transaction,
    5198                     // and we can erase the TRT entry
     5317                    // If the victim is not dirty (RWT: if it is not coherent,
     5318                    // we can not know wether it is dirty or not), we don't
     5319                    // need another XRAM  put transaction, and we can erase the
     5320                    // TRT entry
    51995321                    if(!r_xram_rsp_victim_dirty.read() and (r_xram_rsp_victim_coherent.read() or (r_xram_rsp_victim_count.read() == 0)))  m_trt.erase(r_xram_rsp_trt_index.read());
    52005322
    52015323                    // Next state
    5202                     if(r_xram_rsp_victim_dirty.read() or (!r_xram_rsp_victim_coherent.read() and (r_xram_rsp_victim_count.read() == 1)))       r_xram_rsp_fsm = XRAM_RSP_TRT_DIRTY;
     5324                    if(r_xram_rsp_victim_dirty.read() or (!r_xram_rsp_victim_coherent.read() and (r_xram_rsp_victim_count.read() == 1)))  r_xram_rsp_fsm = XRAM_RSP_TRT_DIRTY;
    52035325                    else if(r_xram_rsp_trt_buf.proc_read)    r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
    52045326                    else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
     
    52355357#endif
    52365358
    5237                         //        if( not r_xram_rsp_victim_coherent )
    5238                         //            std::cout << "a victim coherent not sent trt index =" << r_xram_rsp_trt_index.read() << std::endl;
    52395359                        if(r_xram_rsp_trt_buf.proc_read)         r_xram_rsp_fsm = XRAM_RSP_DIR_RSP;
    52405360                        else if(r_xram_rsp_victim_inval.read())  r_xram_rsp_fsm = XRAM_RSP_INVAL;
     
    53115431                        else                         r_xram_rsp_fsm = XRAM_RSP_IDLE;
    53125432
    5313                         // std::cout << "cleanup sent for trt index =" << r_xram_rsp_trt_index.read() << std::endl;
    53145433#if DEBUG_MEMC_XRAM_RSP
    53155434                        if(m_debug)
     
    53735492                        HeapEntry entry = m_heap.read(r_xram_rsp_next_ptr.read());
    53745493
    5375                         xram_rsp_to_cc_send_fifo_srcid    = entry.owner.srcid;
     5494                        xram_rsp_to_cc_send_fifo_srcid = entry.owner.srcid;
    53765495                        xram_rsp_to_cc_send_fifo_inst  = entry.owner.inst;
    53775496                        xram_rsp_to_cc_send_fifo_put   = true;
     
    53875506                            {
    53885507                                r_xram_rsp_fsm = XRAM_RSP_HEAP_ERASE;
     5508
    53895509                            }
    53905510                        }
     
    54315551                    m_heap.write(r_xram_rsp_next_ptr.read(),last_entry);
    54325552
     5553                    // <Activity counters>
     5554                    m_cpt_heap_slot_available = m_cpt_heap_slot_available + (r_xram_rsp_victim_count.read() - 1);
     5555                    // </Activity counters>
     5556
    54335557                    r_xram_rsp_fsm = XRAM_RSP_IDLE;
    54345558
     
    54465570
    54475571                    // Next state
    5448                     if(r_xram_rsp_trt_buf.proc_read) r_xram_rsp_fsm = XRAM_RSP_ERROR_RSP;
    5449                     else                             r_xram_rsp_fsm = XRAM_RSP_IDLE;
     5572                    if (r_xram_rsp_trt_buf.proc_read)
     5573                    {
     5574                        r_xram_rsp_fsm = XRAM_RSP_ERROR_RSP;
     5575                    }
     5576                    else
     5577                    {
     5578                        // Trigger an interruption to signal a bus error from
     5579                        // the XRAM because a processor WRITE MISS (XRAM GET
     5580                        // transaction and not processor read).
     5581                        //
     5582                        // To avoid deadlocks we do not wait an error to be
     5583                        // acknowledged before signaling another one.
     5584                        // Therefore, when there is an active error, and other
     5585                        // errors arrive, these are not considered
     5586
     5587                        if (!r_xram_rsp_rerror_irq.read() && r_xram_rsp_rerror_irq_enable.read()
     5588                                && r_xram_rsp_trt_buf.xram_read )
     5589                        {
     5590                            r_xram_rsp_rerror_irq     = true;
     5591                            r_xram_rsp_rerror_address = r_xram_rsp_trt_buf.nline * m_words * 4;
     5592                            r_xram_rsp_rerror_rsrcid  = r_xram_rsp_trt_buf.srcid;
    54505593
    54515594#if DEBUG_MEMC_XRAM_RSP
    5452                     if(m_debug)
     5595                            if (m_debug)
     5596                                std::cout
     5597                                    << "  <MEMC " << name() << " XRAM_RSP_ERROR_ERASE>"
     5598                                    << " Triggering interrupt to signal WRITE MISS bus error"
     5599                                    << " / irq_enable = " << r_xram_rsp_rerror_irq_enable.read()
     5600                                    << " / nline = "      << r_xram_rsp_trt_buf.nline
     5601                                    << " / rsrcid = "     << r_xram_rsp_trt_buf.srcid
     5602                                    << std::endl;
     5603#endif
     5604                        }
     5605
     5606                        r_xram_rsp_fsm = XRAM_RSP_IDLE;
     5607                    }
     5608
     5609#if DEBUG_MEMC_XRAM_RSP
     5610                    if (m_debug)
    54535611                        std::cout << "  <MEMC " << name() << " XRAM_RSP_ERROR_ERASE>"
    54545612                            << " Error reported by XRAM / erase the TRT entry" << std::endl;
     
    55725730                        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB);
    55735731
    5574                     //A MODIFIER POUR DIRTY //
    55755732                    bool eop =
    55765733                        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1;
     5734
    55775735                    if (! eop)
    55785736                    {
     
    56435801
    56445802                    r_cleanup_fsm = CLEANUP_DIR_LOCK;
    5645                     //std::cout << " MEM_CACHE : CLEANUP_DIR_REQ" << std::endl;
    56465803
    56475804#if DEBUG_MEMC_CLEANUP
     
    56685825                        exit(0);
    56695826                    }
    5670                     //std::cout << " MEM_CACHE : CLEANUP_DIR_LOCK" << std::endl;
    56715827
    56725828                    // Read the directory
     
    57095865                        }
    57105866                    }
    5711                     else                // miss : check UPT for a pending invalidation transaction
     5867                    else           // miss : check IVT for a pending invalidation transaction
    57125868                    {
    57135869                        r_cleanup_fsm = CLEANUP_IVT_LOCK;
     
    57695925                    /*RWT*/
    57705926                    bool   inval_request = (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) // NCC to CC initiated by a read transaction
    5771                         or (r_write_to_cleanup_req.read() and (r_cleanup_nline.read() == r_write_to_cleanup_nline.read())); //NCC to CC initiated by a wrtie transaction
     5927                        or (r_write_to_cleanup_req.read() and (r_cleanup_nline.read() == r_write_to_cleanup_nline.read()));              // NCC to CC initiated by a write transaction
    57725928
    57735929
     
    57945950                        if (r_read_to_cleanup_cached_read.read())
    57955951                        {
    5796                             entry.count          = r_cleanup_count.read();
    5797                             entry.owner.srcid    = r_read_to_cleanup_srcid.read();
    5798                             entry.owner.inst     = 0;
     5952                            entry.count       = r_cleanup_count.read();
     5953                            entry.owner.srcid = r_read_to_cleanup_srcid.read();
     5954                            entry.owner.inst  = r_read_to_cleanup_inst.read();
    57995955                        }
    58005956                        else
    58015957                        {
    5802                             entry.count          = r_cleanup_count.read() - 1;
    5803                             entry.owner.srcid    = r_cleanup_copy.read();
    5804                             entry.owner.inst     = r_cleanup_copy_inst.read();
     5958                            entry.count       = r_cleanup_count.read() - 1;
     5959                            entry.owner.srcid = r_cleanup_copy.read();
     5960                            entry.owner.inst  = r_cleanup_copy_inst.read();
    58055961                        }
    58065962                        if (r_read_to_cleanup_is_ll.read())
     
    58115967                    else
    58125968                    {
    5813                         entry.count          = r_cleanup_count.read() - 1;
    5814                         entry.owner.srcid    = 0;
    5815                         entry.owner.inst     = 0;
     5969                        entry.count       = r_cleanup_count.read() - 1;
     5970                        entry.owner.srcid = 0;
     5971                        entry.owner.inst  = 0;
     5972
     5973#if REVERT_CC_MECANISM
     5974                        // Revert CC to NCC if :
     5975                        //  - no more copy in L1 caches
     5976                        //  - this line is not in counter mode (broadcast)
     5977                        //  - this line is not in NCC to CC mecanism
     5978                        if (((r_cleanup_count.read() - 1) == 0) and (r_cleanup_is_cnt == false) and (inval_request == false))
     5979                        {
     5980                            entry.cache_coherent = false;
     5981                        }
     5982#endif
     5983
     5984#if REVERT_BC_MECANISM
     5985                        if ((r_cleanup_count.read() - 1) == 0)
     5986                        {
     5987                            entry.is_cnt = false;
     5988                        }
     5989#endif
     5990
    58165991                    }
    58175992
     
    58526027                            << " / is_cnt = "  << entry.is_cnt
    58536028                            << " / match_inval = " << inval_request
     6029                            << " / is_coherent = " << entry.cache_coherent
     6030                            << std::dec
    58546031                            << std::endl;
    58556032                    }
     
    58616038            case CLEANUP_IVT_LOCK_DATA://RWT
    58626039                {
    5863                     //Search for a matching inval in the UPT (there must be one) and check if there is a pending read.
     6040                    //Search for a matching inval in the IVT (there must be one) and check if there is a pending read.
    58646041                    if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CLEANUP)
    58656042                    {
     
    58776054                        r_cleanup_fsm = CLEANUP_IVT_CLEAR_DATA;
    58786055                    }
    5879 #if DEBUG_MC_CLEANUP
     6056#if DEBUG_MEMC_CLEANUP
    58806057                    if (m_debug)
    58816058                    {
     
    59026079                        r_cleanup_fsm = CLEANUP_SEND_CLACK;
    59036080                    }
    5904 #if DEBUG_MC_CLEANUP
     6081#if DEBUG_MEMC_CLEANUP
    59056082                    if (m_debug)
    59066083                    {
    59076084                        std::cout
    59086085                            << " <MEMC " << name()
    5909                             << " CLEANUP_IVT_CLEAR_DATA> clear UPT entry"
     6086                            << " CLEANUP_IVT_CLEAR_DATA> clear IVT entry"
    59106087                            << std::endl;
    59116088                    }
     
    59226099                    r_cleanup_to_tgt_rsp_srcid   = r_cleanup_read_srcid.read();
    59236100                    r_cleanup_to_tgt_rsp_trdid   = r_cleanup_read_trdid.read();
    5924                     r_cleanup_to_tgt_rsp_pktid   = 0x0 + r_cleanup_read_pktid.read();//WT
     6101                    r_cleanup_to_tgt_rsp_pktid   = 0x0 + r_cleanup_read_pktid.read();//RWT
    59256102                    r_cleanup_to_tgt_rsp_type    = 0; //Read instruction
    59266103                    r_cleanup_to_tgt_rsp_length  = r_read_to_cleanup_length.read();
     
    59456122                    r_cleanup_fsm                = CLEANUP_SEND_CLACK;
    59466123
    5947 #if DEBUG_MC_CLEANUP
     6124#if DEBUG_MEMC_CLEANUP
    59486125                    if (m_debug)
    59496126                    {
     
    61976374                    m_heap.write_free_ptr(r_cleanup_next_ptr.read());
    61986375                    m_heap.unset_full();
     6376
     6377                    // <Activity counters>
     6378                    m_cpt_heap_slot_available++;
     6379                    // </Activity counters>
    61996380
    62006381                    r_cleanup_fsm = CLEANUP_SEND_CLACK;
     
    63226503                    if(r_cleanup_to_tgt_rsp_req.read()) break;
    63236504
     6505                    assert ( (r_cleanup_ncc.read() == false) and
     6506                            "CLEANUP_WRITE_RSP : Cleanup on NCC line invalid in "
     6507                            "MEM_CACHE with write_rsp needed. STRANGE BEHAVIOUR");
    63246508                    // no pending request
    63256509                    r_cleanup_to_tgt_rsp_req     = true;
     
    63856569                                        data_vector);
    63866570                            }
    6387                             //std::cout << "cleanup with a non coherent ligne in trt index = " << index << std::endl;
    63886571                            r_cleanup_to_ixr_cmd_srcid        = r_cleanup_srcid.read();
    63896572                            r_cleanup_to_ixr_cmd_index        = index;
     
    72427425        //
    72437426        // It implements a round-robin priority between the four possible client FSMs
    7244         //     XRAM_RSP > CAS > WRITE > CONFIG
     7427        //     XRAM_RSP > CAS > READ > WRITE > CONFIG
    72457428        //
    72467429        // Each FSM can request the next services:
     
    73697552                        break;
    73707553                    }
    7371                     // WRITE
     7554                    // READ
    73727555                    if(r_read_to_cc_send_req.read())
    73737556                    {
     
    73757558                        break;
    73767559                    }
    7377 
     7560                    // WRITE
    73787561                    if(r_write_to_cc_send_req.read())
    73797562                    {
     
    73957578                }
    73967579                ///////////////////////////
    7397             case CC_SEND_XRAM_RSP_IDLE:   // CAS FSM has highest priority
    7398                 {
     7580            case CC_SEND_READ_IDLE:
     7581                {
     7582                    // WRITE
     7583                    if(r_write_to_cc_send_req.read())
     7584                    {
     7585                        r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     7586                        break;
     7587                    }
     7588                    if(m_write_to_cc_send_inst_fifo.rok() or
     7589                            r_write_to_cc_send_multi_req.read())
     7590                    {
     7591                        r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
     7592                        break;
     7593                    }
     7594                    if(r_write_to_cc_send_brdcast_req.read())
     7595                    {
     7596                        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
     7597                        break;
     7598                    }
     7599                    // CONFIG
     7600                    if(r_config_to_cc_send_multi_req.read())
     7601                    {
     7602                        r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
     7603                        break;
     7604                    }
     7605                    if(r_config_to_cc_send_brdcast_req.read())
     7606                    {
     7607                        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
     7608                        break;
     7609                    }
     7610                    // XRAM_RSP
     7611                    if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
     7612                            r_xram_rsp_to_cc_send_multi_req.read())
     7613                    {
     7614                        r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
     7615                        break;
     7616                    }
     7617                    if(r_xram_rsp_to_cc_send_brdcast_req.read())
     7618                    {
     7619                        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
     7620                        break;
     7621                    }
    73997622                    // CAS
    74007623                    if(m_cas_to_cc_send_inst_fifo.rok() or
     
    74097632                        break;
    74107633                    }
    7411 
     7634                    // READ
    74127635                    if(r_read_to_cc_send_req.read())
    74137636                    {
     
    74157638                        break;
    74167639                    }
    7417 
    7418                     if(r_write_to_cc_send_req.read())
    7419                     {
    7420                         r_cc_send_fsm = CC_SEND_WRITE_NCC_INVAL_HEADER;
     7640                    break;
     7641
     7642                }
     7643                ///////////////////////////
     7644            case CC_SEND_XRAM_RSP_IDLE:   // CAS FSM has highest priority
     7645                {
     7646                    // CAS
     7647                    if(m_cas_to_cc_send_inst_fifo.rok() or
     7648                            r_cas_to_cc_send_multi_req.read())
     7649                    {
     7650                        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    74217651                        break;
    74227652                    }
    7423 
    7424 
    7425                     // WRITE
     7653                    if(r_cas_to_cc_send_brdcast_req.read())
     7654                    {
     7655                        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
     7656                        break;
     7657                    }
     7658
     7659                    // READ
    74267660                    if(r_read_to_cc_send_req.read())
    74277661                    {
     
    74307664                    }
    74317665
     7666                    // WRITE
    74327667                    if(r_write_to_cc_send_req.read())
    74337668                    {
     
    74737708                }
    74747709                //////////////////////
    7475             case CC_SEND_CAS_IDLE:   // CLEANUP FSM has highest priority
    7476                 {
    7477 
     7710            case CC_SEND_CAS_IDLE:   // READ FSM has highest priority
     7711                {
     7712
     7713                    // READ
    74787714                    if(r_read_to_cc_send_req.read())
    74797715                    {
     
    74817717                        break;
    74827718                    }
    7483 
     7719                    // WRITE
    74847720                    if(r_write_to_cc_send_req.read())
    74857721                    {
     
    74887724                    }
    74897725
    7490 
    74917726                    if(m_write_to_cc_send_inst_fifo.rok() or
    74927727                            r_write_to_cc_send_multi_req.read())
     
    75117746                        break;
    75127747                    }
     7748                    // XRAM RSP
    75137749                    if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    75147750                            r_xram_rsp_to_cc_send_multi_req.read())
     
    75227758                        break;
    75237759                    }
     7760                    // CAS
    75247761                    if(m_cas_to_cc_send_inst_fifo.rok() or
    75257762                            r_cas_to_cc_send_multi_req.read())
     
    76837920
    76847921                    r_read_to_cc_send_req = false;
    7685                     r_cc_send_fsm = CC_SEND_WRITE_IDLE;
     7922                    r_cc_send_fsm = CC_SEND_READ_IDLE;
    76867923
    76877924#if DEBUG_MEMC_CC_SEND
     
    76917928                            << "  <MEMC " << name()
    76927929                            << " CC_SEND_READ_NCC_INVAL_HEADER> Inval for line "
    7693                             << r_read_to_cc_send_nline.read()
     7930                            << std::hex <<r_read_to_cc_send_nline.read() << std::dec
    76947931                            << std::endl;
    76957932                    }
     
    77207957                            << "  <MEMC " << name()
    77217958                            << " CC_SEND_WRITE_NCC_INVAL_HEADER> Inval for line "
    7722                             << r_write_to_cc_send_nline.read()
     7959                            << std::hex << r_write_to_cc_send_nline.read() << std::dec
    77237960                            << std::endl;
    77247961                    }
     
    83698606                }
    83708607                /////////////////////
    8371             case TGT_RSP_CLEANUP:   // pas clair pour moi (AG)
     8608            case TGT_RSP_CLEANUP:
    83728609                {
    83738610                    if(p_vci_tgt.rspack)
     
    96169853            }
    96179854        }
    9618         //m_cc_receive_to_cleanup_fifo.update( cc_receive_to_cleanup_fifo_get,
    9619         //                                     cc_receive_to_cleanup_fifo_put,
    9620         //                                     p_dspin_p2m.data.read() );
    96219855
    96229856        ////////////////////////////////////////////////////////////////////////////////////
     
    96799913            r_config_rsp_lines = r_config_rsp_lines.read() - 1;
    96809914        }
     9915
     9916        ////////////////////////////////////////////////////////////////////////////////////
     9917        //            Update min m_cpt_heap_min_slot_available.
     9918        // The four sources of (increment / decrement) are READ / CLEANUP / XRAM_RSP / CONFIG FSMs
     9919        ////////////////////////////////////////////////////////////////////////////////////
     9920        assert((m_cpt_heap_slot_available <= m_heap_size) and "m_cpt_heap_slot_available > m_heap_size");
     9921        assert((m_cpt_heap_min_slot_available <= m_heap_size) and "m_cpt_heap_min_slot_available > m_heap_size");
     9922        m_cpt_heap_min_slot_available = min_value(m_cpt_heap_min_slot_available, m_cpt_heap_slot_available);
    96819923
    96829924    } // end transition()
     
    975910001            p_vci_ixr.cmd     = vci_param_ext::CMD_WRITE;
    976010002            p_vci_ixr.cmdval  = true;
    9761             /*p_vci_ixr.address = (addr_t)((r_cleanup_to_ixr_cmd_nline.read() * m_words +
    9762               r_ixr_cmd_word.read()) * 4);*/
    976310003            p_vci_ixr.address = (addr_t)r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2);
    976410004            p_vci_ixr.wdata   = ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read()].read()) |
     
    998810228
    998910229        ////////////////////////////////////////////////////////////////////
     10230        //  p_irq port
     10231        //
     10232        //  WRITE MISS response error signaling
     10233        ////////////////////////////////////////////////////////////////////
     10234
     10235        p_irq =
     10236            r_xram_rsp_rerror_irq.read() &&
     10237            r_xram_rsp_rerror_irq_enable.read();
     10238
     10239        ////////////////////////////////////////////////////////////////////
    999010240        //  p_dspin_m2p port (CC_SEND FSM)
    999110241        ////////////////////////////////////////////////////////////////////
     
    1002610276                            DspinDhccpParam::MULTI_INVAL_DEST);
    1002710277
    10028                     DspinDhccpParam::dspin_set( flit,
    10029                             m_cc_global_id,
    10030                             DspinDhccpParam::MULTI_INVAL_SRCID);
    10031 
    1003210278                    // MODIFIED FOR CONFIG INVAL (solution 1 bit in flit multi_inval)
    1003310279                    DspinDhccpParam::dspin_set( flit,
     
    1008210328
    1008310329                    DspinDhccpParam::dspin_set( flit,
    10084                             m_cc_global_id,
    10085                             DspinDhccpParam::MULTI_INVAL_SRCID);
    10086 
    10087                     DspinDhccpParam::dspin_set( flit,
    1008810330                            r_xram_rsp_to_cc_send_trdid.read(),
    1008910331                            DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
     
    1011910361                            m_broadcast_boundaries,
    1012010362                            DspinDhccpParam::BROADCAST_BOX);
    10121                     // MODIFIED FOR CONFIG INVAL (solution 1 bit in flit multi_inval)
     10363                   
    1012210364                    DspinDhccpParam::dspin_set( flit,
    1012310365                            1,
    1012410366                            DspinDhccpParam::MULTI_INVAL_IS_CONFIG);
    10125 
    10126                     DspinDhccpParam::dspin_set( flit,
    10127                             m_cc_global_id,
    10128                             DspinDhccpParam::BROADCAST_SRCID);
    1012910367
    1013010368                    DspinDhccpParam::dspin_set( flit,
     
    1014510383                            m_broadcast_boundaries,
    1014610384                            DspinDhccpParam::BROADCAST_BOX);
    10147 
    10148                     DspinDhccpParam::dspin_set( flit,
    10149                             m_cc_global_id,
    10150                             DspinDhccpParam::BROADCAST_SRCID);
    1015110385
    1015210386                    DspinDhccpParam::dspin_set( flit,
     
    1020410438                    DspinDhccpParam::dspin_set(
    1020510439                            flit,
    10206                             m_cc_global_id,
    10207                             DspinDhccpParam::MULTI_INVAL_SRCID);
    10208 
    10209                     DspinDhccpParam::dspin_set(
    10210                             flit,
    1021110440                            DspinDhccpParam::TYPE_MULTI_INVAL_DATA,
    1021210441                            DspinDhccpParam::M2P_TYPE);
     
    1024610475                            r_write_to_cc_send_dest.read(),
    1024710476                            DspinDhccpParam::MULTI_INVAL_DEST);
    10248 
    10249                     DspinDhccpParam::dspin_set(
    10250                             flit,
    10251                             m_cc_global_id,
    10252                             DspinDhccpParam::MULTI_INVAL_SRCID);
    1025310477
    1025410478                    DspinDhccpParam::dspin_set(
     
    1033310557                    DspinDhccpParam::dspin_set(
    1033410558                            flit,
    10335                             m_cc_global_id,
    10336                             DspinDhccpParam::MULTI_UPDT_SRCID);
    10337 
    10338                     DspinDhccpParam::dspin_set(
    10339                             flit,
    1034010559                            r_write_to_cc_send_trdid.read(),
    1034110560                            DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
     
    1042310642                            dest,
    1042410643                            DspinDhccpParam::MULTI_UPDT_DEST);
    10425 
    10426                     DspinDhccpParam::dspin_set(
    10427                             flit,
    10428                             m_cc_global_id,
    10429                             DspinDhccpParam::MULTI_UPDT_SRCID);
    1043010644
    1043110645                    DspinDhccpParam::dspin_set(
Note: See TracChangeset for help on using the changeset viewer.