Changeset 816


Ignore:
Timestamp:
Sep 26, 2014, 2:47:09 PM (8 years ago)
Author:
cfuguet
Message:

vci_cc_vcache_wrapper: improve comments in DCACHE FSM

File:
1 edited

Legend:

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

    r809 r816  
    132132const char * vci_pktid_type_str[] = {
    133133        "TYPE_DATA_UNC",
    134         "TYPE_READ_DATA_MISS",           
    135         "TYPE_READ_INS_UNC",         
     134        "TYPE_READ_DATA_MISS",
     135        "TYPE_READ_INS_UNC",
    136136        "TYPE_READ_INS_MISS",
    137137        "TYPE_WRITE",
     
    359359      r_dcache_cleanup_victim_req("r_dcache_cleanup_victim_req"),
    360360      r_dcache_cleanup_victim_nline("r_dcache_cleanup_victim_nline"),
    361    
     361
    362362      r_dcache_cc_send_req("r_dcache_cc_send_req"),
    363363      r_dcache_cc_send_type("r_dcache_cc_send_type"),
     
    567567        std::cout << "Monitor PROC " << name()
    568568                  << " DCACHE at cycle " << std::dec << m_cpt_total_cycles
    569                   << " / HIT = " << cache_hit 
     569                  << " / HIT = " << cache_hit
    570570                  << " / PADDR = " << std::hex << addr
    571                   << " / DATA = " << cache_rdata 
     571                  << " / DATA = " << cache_rdata
    572572                  << " / WAY = " << cache_way << std::endl;
    573573        m_debug_previous_d_hit = cache_hit;
     
    584584        std::cout << "Monitor PROC " << name()
    585585                  << " ICACHE at cycle " << std::dec << m_cpt_total_cycles
    586                   << " / HIT = " << cache_hit 
     586                  << " / HIT = " << cache_hit
    587587                  << " / PADDR = " << std::hex << addr
    588                   << " / DATA = " << cache_rdata 
     588                  << " / DATA = " << cache_rdata
    589589                  << " / WAY = " << cache_way << std::endl;
    590590        m_debug_previous_i_hit = cache_hit;
     
    11151115            else if ((int) r_dcache_xtn_opcode.read() == (int) iss_t::XTN_INST_PADDR_EXT)
    11161116            {
    1117                 r_icache_paddr_ext = r_dcache_save_wdata.read(); 
     1117                r_icache_paddr_ext = r_dcache_save_wdata.read();
    11181118                r_dcache_xtn_req   = false;
    11191119            }
     
    12081208#if DEBUG_ICACHE
    12091209if ( m_debug_icache_fsm )
    1210 std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Privilege Violation" 
     1210std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Privilege Violation"
    12111211          << " : PADDR = " << std::hex << paddr << std::endl;
    12121212#endif
     
    12231223#if DEBUG_ICACHE
    12241224if ( m_debug_icache_fsm )
    1225 std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Executable Violation" 
     1225std::cout << "  <PROC " << name() << " ICACHE_IDLE> MMU Executable Violation"
    12261226          << " : PADDR = " << std::hex << paddr << std::endl;
    12271227#endif
     
    12621262#if DEBUG_ICACHE
    12631263                    if (m_debug_icache_fsm)
    1264                         std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache" 
     1264                        std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache"
    12651265                            << " : PADDR = " << std::hex << paddr << std::endl;
    12661266#endif
     
    12841284#if DEBUG_ICACHE
    12851285                    if (m_debug_icache_fsm)
    1286                         std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache" 
     1286                        std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache"
    12871287                            << " : PADDR = " << std::hex << paddr
    12881288                            << " / INST  = " << cache_inst << std::endl;
     
    12991299                {
    13001300                    std::cout << "  <PROC " << name()
    1301                         << " ICACHE_IDLE> READ UNCACHEABLE in icache" 
     1301                        << " ICACHE_IDLE> READ UNCACHEABLE in icache"
    13021302                        << " : PADDR = " << std::hex << paddr << std::endl;
    13031303                }
     
    15661566    case ICACHE_MISS_SELECT:       // Try to select a slot in associative set,
    15671567                                   // Waiting in this state if no slot available.
    1568                                    // If a victim slot has been choosen and the r_icache_cc_send_req is false, 
    1569                                    // we send the cleanup request in this state. 
     1568                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
     1569                                   // we send the cleanup request in this state.
    15701570                                   // If not, a r_icache_cleanup_victim_req flip-flop is
    15711571                                   // utilized for saving this cleanup request, and it will be sent later
    1572                                    // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR. 
     1572                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
    15731573                                   // The r_icache_miss_clack flip-flop is set
    15741574                                   // when a cleanup is required
     
    16241624                    r_icache_cc_send_nline = victim;
    16251625                    r_icache_cc_send_way   = way;
    1626                     r_icache_cc_send_type  = CC_TYPE_CLEANUP;   
     1626                    r_icache_cc_send_type  = CC_TYPE_CLEANUP;
    16271627                }
    16281628                else
     
    16891689            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
    16901690            r_icache_cc_send_way        = r_icache_miss_way;
    1691             r_icache_cc_send_type       = CC_TYPE_CLEANUP; 
     1691            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
    16921692            r_icache_cleanup_victim_req = false;
    1693         }   
     1693        }
    16941694
    16951695        // coherence clack interrupt
     
    17001700            break;
    17011701        }
    1702        
     1702
    17031703        // coherence interrupt
    17041704        if (r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read())
     
    17781778            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
    17791779            r_icache_cc_send_way        = r_icache_miss_way;
    1780             r_icache_cc_send_type       = CC_TYPE_CLEANUP; 
     1780            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
    17811781            r_icache_cleanup_victim_req = false;
    1782         }   
     1782        }
    17831783
    17841784        // coherence clack interrupt
     
    20512051#endif
    20522052
    2053         // Switch slot state to ZOMBI and send CLEANUP command 
     2053        // Switch slot state to ZOMBI and send CLEANUP command
    20542054        r_icache.write_dir(r_icache_cc_way.read(),
    20552055                           r_icache_cc_set.read(),
     
    22002200    // 6/ Error handling:
    22012201    //    When the MMU is not activated, Read Bus Errors are synchronous events,
    2202     //    Some Write Bus Errors are synchronous events when the request is a non cacheable access 
    2203     //    but some Write Bus Errors are asynchronous events when the request is cacheable access 
     2202    //    Some Write Bus Errors are synchronous events when the request is a non cacheable access
     2203    //    but some Write Bus Errors are asynchronous events when the request is cacheable access
    22042204    //    (processor is not frozen).
    22052205    //    - If a Read Bus Error or a Non Cacheable Write Bus Error is detected, the VCI_RSP FSM sets the
     
    22072207    //      r_vci_rsp_fifo_dcache FIFO, and the synchronous error is signaled
    22082208    //      by the DCACHE FSM.
    2209     //    - If a Cacheable Write Bus Error is detected, the VCI_RSP_FSM signals 
     2209    //    - If a Cacheable Write Bus Error is detected, the VCI_RSP_FSM signals
    22102210    //    the asynchronous error using the setWriteBerr() method.
    22112211    //    When the MMU is activated bus error are rare events, as the MMU
     
    22282228                      // 6) Dirty bit update (processor)      => DCACHE_DIRTY_GET_PTE
    22292229                      // 7) Cacheable read miss (processor)   => DCACHE_MISS_SELECT
    2230                       // 8) Uncacheable read (processor)      => DCACHE_UNC_WAIT
     2230                      // 8) Uncacheable read/write (processor)=> DCACHE_UNC_WAIT
    22312231                      // 9) LL access (processor)             => DCACHE_LL_WAIT
    22322232                      // 10) SC access (processor)            => DCACHE_SC_WAIT
     
    22912291            {
    22922292                // we take into account the paddr extension
    2293                 if (vci_param::N > 32) 
     2293                if (vci_param::N > 32)
    22942294                    paddr = paddr | ((paddr_t) (r_dcache_paddr_ext.read()) << 32);
    22952295            }
     
    27892789                                if (m_debug_dcache_fsm)
    27902790                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2791                                         << " READ MISS in dcache" 
     2791                                        << " READ MISS in dcache"
    27922792                                        << " / PADDR = " << std::hex << paddr << std::endl;
    27932793#endif
     
    28162816                                if (m_debug_dcache_fsm)
    28172817                                    std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2818                                         << " READ HIT in dcache" 
    2819                                         << " : PADDR = " << std::hex << paddr 
     2818                                        << " READ HIT in dcache"
     2819                                        << " : PADDR = " << std::hex << paddr
    28202820                                        << " / DATA  = " << std::hex << cache_rdata << std::endl;
    28212821#endif
     
    28322832                            if (m_debug_dcache_fsm)
    28332833                                std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2834                                     << " READ UNCACHEABLE in dcache" 
     2834                                    << " READ UNCACHEABLE in dcache"
    28352835                                    << " / PADDR = " << std::hex << paddr << std::endl;
    28362836#endif
     
    28922892                                r_dcache_llsc_valid = false;
    28932893
    2894                             if (not cacheable)
    2895                             {                           
     2894                            if (not cacheable) // uncacheable write
     2895                            {
    28962896                                r_dcache_vci_paddr     = paddr;
    28972897                                r_dcache_vci_wdata     = m_dreq.wdata;
     
    31003100                if (m_debug_dcache_fsm)
    31013101                {
    3102                     std::cout << "  <PROC " << name() 
     3102                    std::cout << "  <PROC " << name()
    31033103                        << " DCACHE_TLB_PTE1_GET> HIT in dcache, but unmapped"
    31043104                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     
    31373137                if (m_debug_dcache_fsm)
    31383138                {
    3139                     std::cout << "  <PROC " << name() 
     3139                    std::cout << "  <PROC " << name()
    31403140                        << " DCACHE_TLB_PTE1_GET> HIT in dcache"
    31413141                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     
    31593159                if (m_debug_dcache_fsm)
    31603160                {
    3161                     std::cout << "  <PROC " << name() 
     3161                    std::cout << "  <PROC " << name()
    31623162                        << " DCACHE_TLB_PTE1_GET> HIT in dcache"
    31633163                        << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     
    31863186            if (m_debug_dcache_fsm)
    31873187            {
    3188                 std::cout << "  <PROC " << name() 
     3188                std::cout << "  <PROC " << name()
    31893189                    << " DCACHE_TLB_PTE1_GET> MISS in dcache:"
    31903190                    << " PTE1 address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
     
    32283228        {
    32293229            if (r_dcache_tlb_ins.read())
    3230                 std::cout << "  <PROC " << name() 
     3230                std::cout << "  <PROC " << name()
    32313231                    << " DCACHE_TLB_PTE1_SELECT> Select a slot in ITLB:";
    32323232            else
    3233                 std::cout << "  <PROC " << name() 
     3233                std::cout << "  <PROC " << name()
    32343234                    << ".DCACHE_TLB_PTE1_SELECT> Select a slot in DTLB:";
    32353235            std::cout << " way = " << std::dec << way
     
    32993299                if (m_debug_dcache_fsm)
    33003300                {
    3301                     std::cout << "  <PROC " << name() 
     3301                    std::cout << "  <PROC " << name()
    33023302                        << " DCACHE_TLB_PTE1_UPDT> write PTE1 in ITLB"
    33033303                        << " / set = " << std::dec << r_dcache_tlb_set.read()
     
    33233323                if (m_debug_dcache_fsm)
    33243324                {
    3325                     std::cout << "  <PROC " << name() 
     3325                    std::cout << "  <PROC " << name()
    33263326                        << " DCACHE_TLB_PTE1_UPDT> write PTE1 in DTLB"
    33273327                        << " / set = " << std::dec << r_dcache_tlb_set.read()
     
    33403340            if (m_debug_dcache_fsm)
    33413341            {
    3342                 std::cout << "  <PROC " << name() 
     3342                std::cout << "  <PROC " << name()
    33433343                    << " DCACHE_TLB_PTE1_UPDT> L/R bit update required"
    33443344                    << std::endl;
     
    34283428                if (m_debug_dcache_fsm)
    34293429                {
    3430                     std::cout << "  <PROC " << name() 
     3430                    std::cout << "  <PROC " << name()
    34313431                        << " DCACHE_TLB_PTE2_GET> HIT in dcache:"
    34323432                        << " PTE_FLAGS = " << std::hex << pte_flags
     
    34443444            if (m_debug_dcache_fsm)
    34453445            {
    3446                 std::cout << "  <PROC " << name() 
     3446                std::cout << "  <PROC " << name()
    34473447                    << " DCACHE_TLB_PTE2_GET> ZOMBI in dcache: waiting cleanup ack"
    34483448                    << std::endl;
     
    39463946        {
    39473947            paddr = (paddr_t)r_dcache_save_wdata.read();
    3948             if (vci_param::N > 32) 
     3948            if (vci_param::N > 32)
    39493949                paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
    39503950            hit = true;
     
    40914091    case DCACHE_MISS_SELECT:       // Try to select a slot in associative set,
    40924092                                   // Waiting in this state if no slot available.
    4093                                    // If a victim slot has been choosen and the r_icache_cc_send_req is false, 
    4094                                    // we send the cleanup request in this state. 
     4093                                   // If a victim slot has been choosen and the r_icache_cc_send_req is false,
     4094                                   // we send the cleanup request in this state.
    40954095                                   // If not, a r_icache_cleanup_victim_req flip-flop is
    40964096                                   // utilized for saving this cleanup request, and it will be sent later
    4097                                    // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR. 
     4097                                   // in state ICACHE_MISS_WAIT or ICACHE_MISS_UPDT_DIR.
    40984098                                   // The r_icache_miss_clack flip-flop is set
    40994099                                   // when a cleanup is required
     
    41494149                    r_dcache_cc_send_nline = victim;
    41504150                    r_dcache_cc_send_way   = way;
    4151                     r_dcache_cc_send_type  = CC_TYPE_CLEANUP;   
     4151                    r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
    41524152
    41534153                }
     
    42464246            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline;
    42474247            r_dcache_cc_send_way        = r_dcache_miss_way;
    4248             r_dcache_cc_send_type       = CC_TYPE_CLEANUP; 
     4248            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
    42494249            r_dcache_cleanup_victim_req = false;
    4250         }   
     4250        }
    42514251
    42524252        // coherence clack request (from DSPIN CLACK)
     
    42594259
    42604260        // coherence request (from CC_RECEIVE FSM)
    4261         if (r_cc_receive_dcache_req.read() and 
    4262              not r_dcache_cc_send_req.read() and 
     4261        if (r_cc_receive_dcache_req.read() and
     4262             not r_dcache_cc_send_req.read() and
    42634263             not r_dcache_cleanup_victim_req.read())
    42644264        {
     
    43814381            r_dcache_cc_send_nline      = r_dcache_cleanup_victim_nline;
    43824382            r_dcache_cc_send_way        = r_dcache_miss_way;
    4383             r_dcache_cc_send_type       = CC_TYPE_CLEANUP; 
     4383            r_dcache_cc_send_type       = CC_TYPE_CLEANUP;
    43844384            r_dcache_cleanup_victim_req = false;
    4385         }   
     4385        }
    43864386
    43874387        // coherence clack request (from DSPIN CLACK)
     
    43944394
    43954395        // coherence request (from CC_RECEIVE FSM)
    4396         if (r_cc_receive_dcache_req.read() and 
    4397              not r_dcache_cc_send_req.read() and 
     4396        if (r_cc_receive_dcache_req.read() and
     4397             not r_dcache_cc_send_req.read() and
    43984398             not r_dcache_cleanup_victim_req.read())
    43994399        {
     
    44674467    }
    44684468    /////////////////////
    4469     case DCACHE_UNC_WAIT:  // waiting a response to an uncacheable read
     4469    case DCACHE_UNC_WAIT:  // waiting a response to an uncacheable read/write
    44704470    {
    44714471        // coherence clack request (from DSPIN CLACK)
     
    44914491            else
    44924492                r_mmu_detr = MMU_READ_DATA_ILLEGAL_ACCESS;
    4493                
     4493
    44944494            r_mmu_dbvar          = m_dreq.addr;
    44954495            r_vci_rsp_data_error = false;
     
    47604760        }
    47614761
    4762         assert ( not r_dcache_cc_send_req.read() and 
     4762        assert ( not r_dcache_cc_send_req.read() and
    47634763        "CC_SEND must be available in DCACHE_CC_CHECK" );
    47644764
    47654765        // Match between MISS address and CC address
    4766         if (r_cc_receive_dcache_req.read() and 
     4766        if (r_cc_receive_dcache_req.read() and
    47674767          ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT)  or
    47684768           (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT)  or
     
    48014801
    48024802        // CC request handler
    4803        
     4803
    48044804        int    state = 0;
    48054805        size_t way   = 0;
     
    49014901                "must not be set");
    49024902
    4903         // Switch slot state to ZOMBI and send CLEANUP command 
     4903        // Switch slot state to ZOMBI and send CLEANUP command
    49044904        r_dcache.write_dir(way,
    49054905                           set,
     
    49624962                "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    49634963                "must not be set");
    4964        
     4964
    49654965        if (not r_cc_receive_updt_fifo_be.rok()) break;
    49664966
    49674967        if (r_dcache_cc_need_write.read())
    49684968        {
    4969        
     4969
    49704970#ifdef INSTRUMENTATION
    49714971            m_cpt_dcache_data_write++;
     
    54085408                            {
    54095409                                std::cout << "ERROR in VCI_CC_VCACHE " << name()
    5410                                           << " VCI response packet too short" 
     5410                                          << " VCI response packet too short"
    54115411                                          << " for instruction miss" << std::endl;
    54125412                                exit(0);
     
    55915591            {
    55925592                // the new client is dcache and has a cleanup request
    5593                 if ((update_last_client == 0) and 
     5593                if ((update_last_client == 0) and
    55945594                          (r_dcache_cc_send_type.read() == CC_TYPE_CLEANUP))
    55955595                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
    55965596                // the new client is dcache and has a multi acknowledgement request
    5597                 else if ((update_last_client == 0) and 
     5597                else if ((update_last_client == 0) and
    55985598                          (r_dcache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
    55995599                    r_cc_send_fsm = CC_SEND_MULTI_ACK;
    56005600                // the new client is icache and has a cleanup request
    5601                 else if ((update_last_client == 1) and 
     5601                else if ((update_last_client == 1) and
    56025602                          (r_icache_cc_send_type.read() == CC_TYPE_CLEANUP))
    56035603                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
     
    56805680                }
    56815681                // test for a multi updt
    5682                 else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA) 
     5682                else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA)
    56835683                {
    56845684                    r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_HEADER;
     
    57165716            // not to actually post a request to an available cache => need a
    57175717            // flip_flop to check that ?
    5718             if (not (r_cc_receive_icache_req.read()) and 
     5718            if (not (r_cc_receive_icache_req.read()) and
    57195719                not (r_cc_receive_dcache_req.read()) and
    57205720                (p_dspin_m2p.write.read()))
     
    57575757            uint64_t receive_data = p_dspin_m2p.data.read();
    57585758            // for data INVAL, wait for dcache to take the request
    5759             if (p_dspin_m2p.write.read()           and 
     5759            if (p_dspin_m2p.write.read()           and
    57605760                not r_cc_receive_dcache_req.read())
    57615761            {
     
    57765776            uint64_t receive_data = p_dspin_m2p.data.read();
    57775777            // for ins INVAL, wait for icache to take the request
    5778             if (p_dspin_m2p.write.read()           and 
     5778            if (p_dspin_m2p.write.read()           and
    57795779                not r_cc_receive_icache_req.read())
    57805780            {
     
    58965896
    58975897    ///////////////// DSPIN CLACK interface ///////////////
    5898    
     5898
    58995899    uint64_t clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
    59005900                                                     DspinDhccpParam::CLACK_TYPE);
     
    59775977    p_vci.pktid  = 0;
    59785978    p_vci.srcid  = m_srcid;
    5979     p_vci.cons   = is_sc_or_cas; 
    5980     p_vci.contig = not is_sc_or_cas; 
     5979    p_vci.cons   = is_sc_or_cas;
     5980    p_vci.contig = not is_sc_or_cas;
    59815981    p_vci.wrap   = false;
    59825982    p_vci.clen   = 0;
     
    59855985    if (m_monitor_ok) {
    59865986        if (p_vci.cmdack.read() == true and p_vci.cmdval == true) {
    5987             if (((p_vci.address.read()) >= m_monitor_base) and 
     5987            if (((p_vci.address.read()) >= m_monitor_base) and
    59885988                ((p_vci.address.read()) < m_monitor_base + m_monitor_length)) {
    59895989                std::cout << "CC_VCACHE Monitor " << name() << std::hex
    5990                           << " Access type = " << vci_cmd_type_str[p_vci.cmd.read()] 
     5990                          << " Access type = " << vci_cmd_type_str[p_vci.cmd.read()]
    59915991                          << " Pktid type = " << vci_pktid_type_str[p_vci.pktid.read()]
    59925992                          << " : address = " << p_vci.address.read()
    5993                           << " / be = " << p_vci.be.read(); 
     5993                          << " / be = " << p_vci.be.read();
    59945994                if (p_vci.cmd.read() == vci_param::CMD_WRITE ) {
    59955995                    std::cout << " / data = " << p_vci.wdata.read();
     
    61396139    } // end switch r_vci_rsp_fsm
    61406140
    6141    
    6142     // Send coherence packets on DSPIN P2M 
    6143     // it depends on the CC_SEND FSM 
     6141
     6142    // Send coherence packets on DSPIN P2M
     6143    // it depends on the CC_SEND FSM
    61446144
    61456145    uint64_t dspin_send_data = 0;
     
    61656165            if (r_cc_send_last_client.read() == 0) // dcache active request
    61666166            {
    6167                 uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read() 
    6168                                 >> (m_nline_width - m_x_width - m_y_width) 
     6167                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
     6168                                >> (m_nline_width - m_x_width - m_y_width)
    61696169                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6170  
     6170
    61716171                DspinDhccpParam::dspin_set(dspin_send_data,
    61726172                                           dest,
     
    61876187            else                                // icache active request
    61886188            {
    6189                 uint64_t dest = (uint64_t) r_icache_cc_send_nline.read() 
    6190                                 >> (m_nline_width - m_x_width - m_y_width) 
     6189                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
     6190                                >> (m_nline_width - m_x_width - m_y_width)
    61916191                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    61926192
     
    62496249            if (r_cc_send_last_client.read() == 0) // dcache active request
    62506250            {
    6251                 uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read() 
    6252                                 >> (m_nline_width - m_x_width - m_y_width) 
     6251                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
     6252                                >> (m_nline_width - m_x_width - m_y_width)
    62536253                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6254  
     6254
    62556255                DspinDhccpParam::dspin_set(dspin_send_data,
    62566256                                           dest,
     
    62636263            else                                    // icache active request
    62646264            {
    6265                 uint64_t dest = (uint64_t) r_icache_cc_send_nline.read() 
    6266                                 >> (m_nline_width - m_x_width - m_y_width) 
     6265                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
     6266                                >> (m_nline_width - m_x_width - m_y_width)
    62676267                                << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6268  
     6268
    62696269
    62706270                DspinDhccpParam::dspin_set(dspin_send_data,
     
    62866286
    62876287    // Receive coherence packets
    6288     // It depends on the CC_RECEIVE FSM 
     6288    // It depends on the CC_RECEIVE FSM
    62896289    switch (r_cc_receive_fsm.read())
    62906290    {
     
    63436343        case CC_RECEIVE_INS_UPDT_HEADER:
    63446344        {
    6345             if (not r_cc_receive_icache_req.read()) 
     6345            if (not r_cc_receive_icache_req.read())
    63466346                p_dspin_m2p.read = true;
    63476347            else
     
    63986398    }
    63996399
    6400     p_dspin_clack.read = dspin_clack_get; 
     6400    p_dspin_clack.read = dspin_clack_get;
    64016401} // end genMoore
    64026402
Note: See TracChangeset for help on using the changeset viewer.