Ignore:
Timestamp:
Sep 24, 2014, 3:48:50 PM (10 years ago)
Author:
devigne
Message:

RWT commit : Cosmetic (Remove trailing whitespace)

Location:
branches/RWT/modules/vci_mem_cache
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/RWT/modules/vci_mem_cache

  • branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r787 r814  
    135135        "MULTI_ACK_UPT_LOCK",
    136136        "MULTI_ACK_UPT_CLEAR",
    137         "MULTI_ACK_WRITE_RSP",
     137        "MULTI_ACK_WRITE_RSP"
    138138    };
    139139    const char *config_fsm_str[] =
    … …  
    496496#if MONITOR_MEMCACHE_FSM == 1
    497497            ,
    498         p_read_fsm("p_read_fsm"), 
    499         p_write_fsm("p_write_fsm"), 
    500         p_xram_rsp_fsm("p_xram_rsp_fsm"), 
    501         p_cas_fsm("p_cas_fsm"), 
    502         p_cleanup_fsm("p_cleanup_fsm"), 
    503         p_config_fsm("p_config_fsm"), 
    504         p_alloc_heap_fsm("p_alloc_heap_fsm"), 
    505         p_alloc_dir_fsm("p_alloc_dir_fsm"), 
    506         p_alloc_trt_fsm("p_alloc_trt_fsm"), 
    507         p_alloc_upt_fsm("p_alloc_upt_fsm"), 
    508         p_alloc_ivt_fsm("p_alloc_ivt_fsm"), 
    509         p_tgt_cmd_fsm("p_tgt_cmd_fsm"), 
    510         p_tgt_rsp_fsm("p_tgt_rsp_fsm"), 
    511         p_ixr_cmd_fsm("p_ixr_cmd_fsm"), 
    512         p_ixr_rsp_fsm("p_ixr_rsp_fsm"), 
    513         p_cc_send_fsm("p_cc_send_fsm"), 
     498        p_read_fsm("p_read_fsm"),
     499        p_write_fsm("p_write_fsm"),
     500        p_xram_rsp_fsm("p_xram_rsp_fsm"),
     501        p_cas_fsm("p_cas_fsm"),
     502        p_cleanup_fsm("p_cleanup_fsm"),
     503        p_config_fsm("p_config_fsm"),
     504        p_alloc_heap_fsm("p_alloc_heap_fsm"),
     505        p_alloc_dir_fsm("p_alloc_dir_fsm"),
     506        p_alloc_trt_fsm("p_alloc_trt_fsm"),
     507        p_alloc_upt_fsm("p_alloc_upt_fsm"),
     508        p_alloc_ivt_fsm("p_alloc_ivt_fsm"),
     509        p_tgt_cmd_fsm("p_tgt_cmd_fsm"),
     510        p_tgt_rsp_fsm("p_tgt_rsp_fsm"),
     511        p_ixr_cmd_fsm("p_ixr_cmd_fsm"),
     512        p_ixr_rsp_fsm("p_ixr_rsp_fsm"),
     513        p_cc_send_fsm("p_cc_send_fsm"),
    514514        p_cc_receive_fsm("p_cc_receive_fsm"),
    515515        p_multi_ack_fsm("p_multi_ack_fsm")
    … …  
    629629            {
    630630                m_debug_data[word] = m_cache_data.read(way, set, word);
    631                 if ( m_debug_previous_valid and 
     631                if ( m_debug_previous_valid and
    632632                        (m_debug_data[word] != m_debug_previous_data[word]) )
    633633                {
    … …  
    647647                << " / VAL = " << std::dec << entry.valid
    648648                << " / WAY = " << way
    649                 << " / COUNT = " << entry.count 
     649                << " / COUNT = " << entry.count
    650650                << " / DIRTY = " << entry.dirty
    651                 << " / DATA_CHANGE = " << data_change 
     651                << " / DATA_CHANGE = " << data_change
    652652                << std::endl;
    653653            std::cout << std::hex << "     /0:" << m_debug_data[0]
    … …  
    672672        m_debug_previous_valid = entry.valid;
    673673        m_debug_previous_dirty = entry.dirty;
    674         for( size_t word=0 ; word<m_words ; word++ ) 
     674        for( size_t word=0 ; word<m_words ; word++ )
    675675            m_debug_previous_data[word] = m_debug_data[word];
    676676    }
    … …  
    840840    }
    841841
    842    
     842
    843843    /////////////////////////////////////////
    844844    tmpl(void)::reset_counters()
    … …  
    874874        m_cpt_update_remote       = 0;
    875875        m_cpt_update_cost         = 0;
    876        
     876
    877877        m_cpt_minval              = 0;
    878878        m_cpt_minval_local        = 0;
    … …  
    893893        m_cpt_write_miss          = 0;
    894894        m_cpt_write_dirty         = 0;
    895        
     895
    896896        m_cpt_trt_rb              = 0;
    897897        m_cpt_trt_full            = 0;
    … …  
    13291329        // The READ/WRITE commands accepted in the configuration segment are targeting
    13301330        // configuration or status registers. They must contain one single flit.
    1331         // - For almost all addressable registers, the response is returned immediately. 
     1331        // - For almost all addressable registers, the response is returned immediately.
    13321332        // - For MEMC_CMD_TYPE, the response is delayed until the operation is completed.
    13331333        ////////////////////////////////////////////////////////////////////////////////////
    … …  
    13661366                        else                       r_tgt_cmd_fsm = TGT_CMD_CONFIG;
    13671367                    }
    1368                     else                            //////////// memory access 
     1368                    else                            //////////// memory access
    13691369                    {
    13701370                        if ( p_vci_tgt.cmd.read() == vci_param_int::CMD_READ )
    … …  
    14111411
    14121412                            if((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
    1413                             else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE; 
     1413                            else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE;
    14141414                        }
    14151415                        else
    … …  
    15091509                                  m_config_func_idx_mask;
    15101510
    1511                     bool     need_rsp; 
    1512                     int      error; 
     1511                    bool     need_rsp;
     1512                    int      error;
    15131513                    uint32_t rdata = 0;         // default value
    15141514                    uint32_t wdata = p_vci_tgt.wdata.read();
    … …  
    16171617
    16181618                                        break;
    1619                                        
     1619
    16201620                                    default:
    16211621                                        error = 1;
    … …  
    17191719                    size_t   cell     = (address - seg_base)/vci_param_int::B;
    17201720
    1721                     bool     need_rsp; 
    1722                     size_t   error; 
     1721                    bool     need_rsp;
     1722                    size_t   error;
    17231723                    uint32_t rdata = 0;         // default value
    1724                     uint32_t wdata = p_vci_tgt.wdata.read();     
     1724                    uint32_t wdata = p_vci_tgt.wdata.read();
    17251725
    17261726                    if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
    … …  
    18301830                        << " read command packet must contain one single flit" << std::endl;
    18311831                    exit(0);
    1832                 } 
     1832                }
    18331833                // check plen for LL
    1834                 if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and 
     1834                if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
    18351835                        (p_vci_tgt.plen.read() != 8) )
    18361836                {
    … …  
    18671867                    }
    18681868                    else {
    1869                         if (is_local_req(p_vci_tgt.srcid.read())) 
     1869                        if (is_local_req(p_vci_tgt.srcid.read()))
    18701870                        {
    18711871                            m_cpt_read_local++;
    … …  
    19101910                            m_cpt_write_flits_local++;
    19111911                        }
    1912                         else 
     1912                        else
    19131913                        {
    19141914                            m_cpt_write_flits_remote++;
    … …  
    19261926                                m_cpt_sc_local++;
    19271927                            }
    1928                             else 
     1928                            else
    19291929                            {
    19301930                                m_cpt_sc_remote++;
    … …  
    19321932                        }
    19331933                        else {
    1934                             if (is_local_req(p_vci_tgt.srcid.read())) 
     1934                            if (is_local_req(p_vci_tgt.srcid.read()))
    19351935                            {
    19361936                                m_cpt_write_local++;
    … …  
    19731973                    if (p_vci_tgt.eop) {
    19741974                        // <Activity counters>
    1975                         if (is_local_req(p_vci_tgt.srcid.read())) 
     1975                        if (is_local_req(p_vci_tgt.srcid.read()))
    19761976                        {
    19771977                            m_cpt_cas_local++;
    … …  
    19931993        //    MULTI_ACK FSM
    19941994        /////////////////////////////////////////////////////////////////////////
    1995         // This FSM controls the response to the multicast update requests sent 
     1995        // This FSM controls the response to the multicast update requests sent
    19961996        // by the memory cache to the L1 caches and update the UPT.
    19971997        //
    … …  
    21332133                /////////////////////////
    21342134            case MULTI_ACK_WRITE_RSP:     // Post a response request to TGT_RSP FSM
    2135                 // Wait if pending request 
     2135                // Wait if pending request
    21362136                {
    21372137                    if ( r_multi_ack_to_tgt_rsp_req.read() ) break;
    … …  
    21682168
    21692169        //
    2170         // For both INVAL and SYNC commands, the CONFIG FSM contains the loop handling 
     2170        // For both INVAL and SYNC commands, the CONFIG FSM contains the loop handling
    21712171        //
    21722172        // all cache lines covered by the buffer. The various lines of a given buffer
    21732173        // can be pipelined: the CONFIG FSM does not wait the response for line (n) to send
    2174         // the command for line (n+1). It decrements the r_config_cmd_lines counter until 
     2174        // the command for line (n+1). It decrements the r_config_cmd_lines counter until
    21752175        // the last request has been registered in TRT (for a SYNC), or in IVT (for an INVAL).
    21762176        // The r_config_rsp_lines counter contains the number of expected responses from
    … …  
    21802180        // be concurently accessed by those three FSMs, it is implemented as an [incr/decr]
    21812181        // counter.
    2182         // 
     2182        //
    21832183        // - INVAL request:
    2184         //   For each line, it access to the DIR. 
    2185         //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM. 
     2184        //   For each line, it access to the DIR.
     2185        //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM.
    21862186        //   In case of hit, with no copies in L1 caches, the line is invalidated and
    21872187        //   a response is requested to TGT_RSP FSM.
    … …  
    21952195        //   This constraint can be released, but it requires to make 2 PUT transactions
    21962196        //   for the first and the last line...
    2197         // 
     2197        //
    21982198        // - SYNC request:
    2199         //   For each line, it access to the DIR. 
    2200         //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM. 
     2199        //   For each line, it access to the DIR.
     2200        //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM.
    22012201        //   In case of hit, a PUT transaction is registered in TRT and a request is sent
    22022202        //   to IXR_CMD FSM. The IXR_RSP FSM decrements the r_config_rsp_lines counter
    … …  
    22052205        //
    22062206        // From the software point of view, a configuration request is a sequence
    2207         // of 6 atomic accesses in an uncached segment. A dedicated lock is used 
     2207        // of 6 atomic accesses in an uncached segment. A dedicated lock is used
    22082208        // to handle only one configuration command at a given time:
    22092209        // - Read  MEMC_LOCK       : Get the lock
    … …  
    22182218        {
    22192219            /////////////////
    2220             case CONFIG_IDLE:  // waiting a config request 
    2221                 {
    2222                     if ( r_config_cmd.read() != MEMC_CMD_NOP ) 
     2220            case CONFIG_IDLE:  // waiting a config request
     2221                {
     2222                    if ( r_config_cmd.read() != MEMC_CMD_NOP )
    22232223                    {
    22242224                        r_config_fsm    = CONFIG_LOOP;
    … …  
    22262226#if DEBUG_MEMC_CONFIG
    22272227                        if(m_debug)
    2228                             std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received" 
     2228                            std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received"
    22292229                                << " address = " << std::hex << r_config_address.read()
    22302230                                << " / nlines = " << std::dec << r_config_cmd_lines.read()
    … …  
    22352235                }
    22362236                /////////////////
    2237             case CONFIG_LOOP:   // test last line to be handled 
     2237            case CONFIG_LOOP:   // test last line to be handled
    22382238                {
    22392239                    if ( r_config_cmd_lines.read() == 0 )
    … …  
    22492249#if DEBUG_MEMC_CONFIG
    22502250                    if(m_debug)
    2251                         std::cout << "  <MEMC " << name() << " CONFIG_LOOP>" 
    2252                             << " address = " << std::hex << r_config_address.read()   
    2253                             << " / nlines = " << std::dec << r_config_cmd_lines.read() 
     2251                        std::cout << "  <MEMC " << name() << " CONFIG_LOOP>"
     2252                            << " address = " << std::hex << r_config_address.read()
     2253                            << " / nlines = " << std::dec << r_config_cmd_lines.read()
    22542254                            << " / command = " << r_config_cmd.read() << std::endl;
    22552255#endif
    … …  
    22572257                }
    22582258                /////////////////
    2259             case CONFIG_WAIT:   // wait completion (last response) 
     2259            case CONFIG_WAIT:   // wait completion (last response)
    22602260                {
    22612261                    if ( r_config_rsp_lines.read() == 0 )  // last response received
    … …  
    22662266#if DEBUG_MEMC_CONFIG
    22672267                    if(m_debug)
    2268                         std::cout << "  <MEMC " << name() << " CONFIG_WAIT>" 
     2268                        std::cout << "  <MEMC " << name() << " CONFIG_WAIT>"
    22692269                            << " / lines to do = " << std::dec << r_config_rsp_lines.read() << std::endl;
    22702270#endif
    … …  
    22722272                }
    22732273                ////////////////
    2274             case CONFIG_RSP:  // request TGT_RSP FSM to return response 
     2274            case CONFIG_RSP:  // request TGT_RSP FSM to return response
    22752275                {
    22762276                    if ( not r_config_to_tgt_rsp_req.read() )
    … …  
    23292329
    23302330                    if (entry.valid and                            // hit & inval command
    2331                             (r_config_cmd.read() == MEMC_CMD_INVAL)) 
     2331                            (r_config_cmd.read() == MEMC_CMD_INVAL))
    23322332                    {
    23332333                        r_config_fsm    = CONFIG_IVT_LOCK;
    … …  
    23362336                            entry.dirty and
    23372337                            (r_config_cmd.read() == MEMC_CMD_SYNC) )
    2338                     { 
     2338                    {
    23392339                        r_config_fsm = CONFIG_TRT_LOCK;
    23402340                    }
    2341                     else                                            // return to LOOP 
     2341                    else                                            // return to LOOP
    23422342                    {
    23432343                        r_config_cmd_lines = r_config_cmd_lines.read() - 1;
    … …  
    23592359                /////////////////////
    23602360            case CONFIG_TRT_LOCK:      // enter this state in case of SYNC command
    2361                 // to a dirty cache line 
     2361                // to a dirty cache line
    23622362                // keep DIR lock, and try to get TRT lock
    23632363                // return to LOOP state if TRT full
    … …  
    24232423                    std::vector<data_t> data_vector;
    24242424                    data_vector.clear();
    2425                     for(size_t word=0; word<m_words; word++) 
     2425                    for(size_t word=0; word<m_words; word++)
    24262426                    {
    24272427                        uint32_t data = m_cache_data.read( way, set, word );
    … …  
    24392439                            0,                                   // read_length: unused
    24402440                            0,                                   // word_index:  unused
    2441                             std::vector<be_t>(m_words,0xF),      // byte-enable:     unused 
     2441                            std::vector<be_t>(m_words,0xF),      // byte-enable:     unused
    24422442                            data_vector,                         // data to be written
    24432443                            0,                                   // ll_key:          unused
    … …  
    24702470                        if(m_debug)
    24712471                            std::cout << "  <MEMC " << name() << " CONFIG_PUT_REQ> post PUT request to IXR_CMD_FSM"
    2472                                 << " / address = " << std::hex << r_config_address.read() << std::endl; 
     2472                                << " / address = " << std::hex << r_config_address.read() << std::endl;
    24732473#endif
    24742474                    }
    … …  
    24802480                // Return to LOOP state if IVT full.
    24812481                // Register inval in IVT, and invalidate the
    2482                 // directory if IVT not full. 
     2482                // directory if IVT not full.
    24832483                {
    24842484                    assert( (r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG) and
    … …  
    25152515
    25162516                            wok = m_ivt.set(false,       // it's an inval transaction
    2517                                     broadcast,   
     2517                                    broadcast,
    25182518                                    false,       // no response required
    25192519                                    true,        // acknowledge required
    … …  
    25582558            case CONFIG_BC_SEND:    // Post a broadcast inval request to CC_SEND FSM
    25592559                {
    2560                     if( not r_config_to_cc_send_multi_req.read() and 
     2560                    if( not r_config_to_cc_send_multi_req.read() and
    25612561                            not r_config_to_cc_send_brdcast_req.read() )
    25622562                    {
    … …  
    25752575                        if(m_debug)
    25762576                            std::cout << "  <MEMC " << name() << " CONFIG_BC_SEND>"
    2577                                 << " Post a broadcast inval request to CC_SEND FSM" 
     2577                                << " Post a broadcast inval request to CC_SEND FSM"
    25782578                                << " / address = " << r_config_address.read() <<std::endl;
    25792579#endif
    … …  
    25842584            case CONFIG_INVAL_SEND:    // Post a multi inval request to CC_SEND FSM
    25852585                {
    2586                     if( not r_config_to_cc_send_multi_req.read() and 
     2586                    if( not r_config_to_cc_send_multi_req.read() and
    25872587                            not r_config_to_cc_send_brdcast_req.read() )
    25882588                    {
    … …  
    26122612                        if(m_debug)
    26132613                            std::cout << "  <MEMC " << name() << " CONFIG_INVAL_SEND>"
    2614                                 << " Post multi inval request to CC_SEND FSM" 
    2615                                 << " / address = " << std::hex << r_config_address.read() 
    2616                                 << " / copy = " << r_config_dir_copy_srcid.read() 
     2614                                << " Post multi inval request to CC_SEND FSM"
     2615                                << " / address = " << std::hex << r_config_address.read()
     2616                                << " / copy = " << r_config_dir_copy_srcid.read()
    26172617                                << " / inst = " << std::dec << r_config_dir_copy_inst.read() << std::endl;
    26182618#endif
    … …  
    26402640                {
    26412641                    HeapEntry entry = m_heap.read( r_config_heap_next.read() );
    2642                     bool last_copy  = (entry.next == r_config_heap_next.read()); 
     2642                    bool last_copy  = (entry.next == r_config_heap_next.read());
    26432643
    26442644                    config_to_cc_send_fifo_srcid = entry.owner.srcid;
    … …  
    26602660                    if(m_debug)
    26612661                        std::cout << "  <MEMC " << name() << " CONFIG_HEAP_SCAN>"
    2662                             << " Post multi inval request to CC_SEND FSM" 
    2663                             << " / address = " << std::hex << r_config_address.read() 
    2664                             << " / copy = " << entry.owner.srcid 
     2662                            << " Post multi inval request to CC_SEND FSM"
     2663                            << " / address = " << std::hex << r_config_address.read()
     2664                            << " / copy = " << entry.owner.srcid
    26652665                            << " / inst = " << std::dec << entry.owner.inst << std::endl;
    26662666#endif
    … …  
    26812681                    }
    26822682                    else
    2683                     { 
     2683                    {
    26842684                        last_entry.next = free_pointer;
    26852685                    }
    … …  
    27992799
    28002800                        // 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)
    2801                         if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read())) 
     2801                        if (entry.cache_coherent or (entry.count == 0))// or (entry.owner.srcid == m_cmd_read_srcid_fifo.read()))
    28022802                        {
    28032803                            // test if we need to register a new copy in the heap
    … …  
    28512851                            {
    28522852                                std::cout
    2853                                     << "  <MEMC " << name() << " READ_IVT_LOCK>" 
     2853                                    << "  <MEMC " << name() << " READ_IVT_LOCK>"
    28542854                                    << " Wait cleanup completion"
    28552855                                    << std::endl;
    … …  
    28622862                            r_read_to_cc_send_dest = r_read_copy.read();
    28632863                            r_read_to_cc_send_nline = nline;
    2864                             r_read_to_cc_send_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0); 
     2864                            r_read_to_cc_send_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    28652865                            r_read_to_cleanup_req = true;
    28662866                            r_read_to_cleanup_nline = nline;
    28672867                            r_read_to_cleanup_srcid = m_cmd_read_srcid_fifo.read();
    2868                             r_read_to_cleanup_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0); 
     2868                            r_read_to_cleanup_inst = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    28692869                            r_read_to_cleanup_length  = m_cmd_read_length_fifo.read();
    28702870                            r_read_to_cleanup_first_word = m_x[(addr_t) m_cmd_read_addr_fifo.read()];
    … …  
    29202920                    break;
    29212921                }
    2922                 ///////////////////                     
     2922                ///////////////////
    29232923            case READ_DIR_HIT:    //  read data in cache & update the directory
    29242924                //  we enter this state in 3 cases:
    … …  
    30243024                        bool go_cnt = (r_read_count.read() >= m_max_copies) or m_heap.is_full();
    30253025
    3026                         if (!r_read_coherent.read())
    3027                         {
    3028                             std::cout << "Address = " << std::hex << (m_cmd_read_addr_fifo.read()) << std::dec << " |count = " << r_read_count.read() << std::endl;
    3029                         }
    3030                         assert (r_read_coherent.read() && "accÚs au heap sur ncc");
     3026                        assert (r_read_coherent.read() && "Heap access on line NCC");
    30313027                        // read data in the cache
    30323028                        size_t set = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    … …  
    31353131                            m_heap.set_full();
    31363132                        }
    3137                        
     3133
    31383134                        // <Activity counters>
    31393135                        m_cpt_heap_slot_available--;
    … …  
    34183414                            << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
    34193415                            << " / address = " << std::hex << m_cmd_write_addr_fifo.read()
    3420                             << " / data = " << m_cmd_write_data_fifo.read() 
    3421                             << " / pktid = " << m_cmd_write_pktid_fifo.read() 
     3416                            << " / data = " << m_cmd_write_data_fifo.read()
     3417                            << " / pktid = " << m_cmd_write_pktid_fifo.read()
    34223418                            << std::endl;
    34233419#endif
    … …  
    34313427
    34323428                    // check that the next word is in the same cache line
    3433                     assert((m_nline[(addr_t)(r_write_address.read())] == 
     3429                    assert((m_nline[(addr_t)(r_write_address.read())] ==
    34343430                                m_nline[(addr_t)(m_cmd_write_addr_fifo.read())]) &&
    34353431                            "MEMC ERROR in WRITE_NEXT state: Illegal write burst");
    … …  
    34823478                        // test address and key match of the SC command on the
    34833479                        // LL/SC table without removing reservation. The reservation
    3484                         // will be erased after in this FSM. 
     3480                        // will be erased after in this FSM.
    34853481                        bool sc_success = m_llsc_table.check(r_write_address.read(),
    34863482                                r_write_sc_key.read());
    … …  
    34933489                    else
    34943490                    {
    3495                         // write burst 
     3491                        // write burst
    34963492#define L2 soclib::common::uint32_log2
    34973493                        addr_t min = r_write_address.read();
    … …  
    35943590                        addr_t nline = m_nline[(addr_t)(r_write_address.read())];
    35953591
    3596                         //if there is a matched updt req, we should wait until it is over. Because 
     3592                        //if there is a matched updt req, we should wait until it is over. Because
    35973593                        //we need the lastest updt data.
    35983594                        match_inval = m_ivt.search_inval(nline, index);
    … …  
    36003596                        assert ((r_write_count.read() == 1) and "NCC to CC req without copy");
    36013597
    3602                         if( not match_inval                          and 
     3598                        if( not match_inval                          and
    36033599                            not m_ivt.is_full()                      and
    36043600                            not r_write_to_cc_send_req.read()        and
    … …  
    36763672                    // no_update is true when there is no need for coherence transaction
    36773673                    bool no_update = ( (r_write_count.read() == 0) or
    3678                             (owner and (r_write_count.read() == 1) and 
     3674                            (owner and (r_write_count.read() == 1) and
    36793675                             ((r_write_pktid.read() & 0x7) != TYPE_SC)));
    36803676
    … …  
    36823678                    if(no_update)
    36833679                    {
    3684                         // SC command but zero copies 
     3680                        // SC command but zero copies
    36853681                        if ((r_write_pktid.read() & 0x7) == TYPE_SC)
    36863682                        {
    … …  
    37263722                        if(no_update)
    37273723                        {
    3728                             std::cout << "  <MEMC " << name() 
     3724                            std::cout << "  <MEMC " << name()
    37293725                                << " WRITE_DIR_HIT> Write into cache / No coherence transaction"
    37303726                                << std::endl;
    … …  
    37613757                                true,  // response required
    37623758                                false, // no acknowledge required
    3763                                 srcid,   
     3759                                srcid,
    37643760                                trdid,
    37653761                                pktid,
    … …  
    37923788                            if(wok)
    37933789                            {
    3794                                 std::cout << "  <MEMC " << name() 
     3790                                std::cout << "  <MEMC " << name()
    37953791                                    << " WRITE_UPT_LOCK> Register the multicast update in UPT / "
    37963792                                    << " nb_copies = " << r_write_count.read() << std::endl;
    … …  
    38143810#if DEBUG_MEMC_WRITE
    38153811                        if(m_debug)
    3816                             std::cout << "  <MEMC " << name() 
     3812                            std::cout << "  <MEMC " << name()
    38173813                                << " WRITE_UPT_HEAP_LOCK> Get acces to the HEAP" << std::endl;
    38183814#endif
    … …  
    39063902
    39073903                    // put the next srcid in the fifo
    3908                     if ((entry.owner.srcid != r_write_srcid.read()) or 
     3904                    if ((entry.owner.srcid != r_write_srcid.read()) or
    39093905                            ((r_write_pktid.read() & 0x7) == TYPE_SC)    or
    39103906                            entry.owner.inst)
    … …  
    40264022
    40274023                                r_write_sc_key = m_cmd_write_data_fifo.read();
    4028                             } 
     4024                            }
    40294025
    40304026                            // initialize the be field for all words
    … …  
    40494045                        {
    40504046                            std::cout << "  <MEMC " << name() << " WRITE_RSP> Post a request to TGT_RSP FSM"
    4051                                 << " : rsrcid = " << std::hex << r_write_srcid.read() 
    4052                                 << " : rpktid = " << std::hex << r_write_pktid.read() 
     4047                                << " : rsrcid = " << std::hex << r_write_srcid.read()
     4048                                << " : rpktid = " << std::hex << r_write_pktid.read()
    40534049                                << " : sc_fail= " << std::hex << r_write_sc_fail.read()
    40544050                                << std::endl;
    … …  
    40584054                                    << " srcid = " << std::hex << m_cmd_write_srcid_fifo.read()
    40594055                                    << " / address = " << m_cmd_write_addr_fifo.read()
    4060                                     << " / data = " << m_cmd_write_data_fifo.read() 
    4061                                     << " / pktid = " << m_cmd_write_pktid_fifo.read() 
     4056                                    << " / data = " << m_cmd_write_data_fifo.read()
     4057                                    << " / pktid = " << m_cmd_write_pktid_fifo.read()
    40624058                                    << std::endl;
    40634059                            }
    … …  
    40684064                }
    40694065                ///////////////////////// RWT
    4070             case WRITE_MISS_IVT_LOCK: 
     4066            case WRITE_MISS_IVT_LOCK:
    40714067                {
    40724068                    if (r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    … …  
    42244220#if DEBUG_MEMC_WRITE
    42254221                        if(m_debug)
    4226                             std::cout << "  <MEMC " << name() 
     4222                            std::cout << "  <MEMC " << name()
    42274223                                << " WRITE_MISS_XRAM_REQ> Post a GET request to the"
    42284224                                << " IXR_CMD FSM" << std::endl;
    … …  
    42824278#if DEBUG_MEMC_WRITE
    42834279                        if(m_debug)
    4284                             std::cout 
     4280                            std::cout
    42854281                                << "  <MEMC "  << name()
    42864282                                << " WRITE_BC_TRT_LOCK> Complete data buffer" << std::endl;
    … …  
    44764472        //
    44774473        // - It sends a single flit VCI read to the XRAM in case of
    4478         //   GET request posted by the READ, WRITE or CAS FSMs. 
     4474        //   GET request posted by the READ, WRITE or CAS FSMs.
    44794475        // - It sends a multi-flit VCI write in case of PUT request posted by
    44804476        //   the XRAM_RSP, WRITE, CAS, or CONFIG FSMs.
    … …  
    45354531                else if(r_config_to_ixr_cmd_req.read())     r_ixr_cmd_fsm = IXR_CMD_CONFIG_TRT;
    45364532                else if(r_cleanup_to_ixr_cmd_req)           r_ixr_cmd_fsm = IXR_CMD_CLEANUP_TRT;
    4537                 break;     
     4533                break;
    45384534                /////////////////////////
    45394535            case IXR_CMD_CONFIG_IDLE:
    … …  
    45974593                }
    45984594                /////////////////////
    4599             case IXR_CMD_CAS_TRT:       // access TRT for a PUT or a GET 
     4595            case IXR_CMD_CAS_TRT:       // access TRT for a PUT or a GET
    46004596                {
    46014597                    if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    … …  
    46244620                }
    46254621                //////////////////////
    4626             case IXR_CMD_XRAM_TRT:       // access TRT for a PUT 
     4622            case IXR_CMD_XRAM_TRT:       // access TRT for a PUT
    46274623                {
    46284624                    if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    … …  
    46464642                }
    46474643                //////////////////////
    4648             case IXR_CMD_CLEANUP_TRT:       // access TRT for a PUT 
     4644            case IXR_CMD_CLEANUP_TRT:       // access TRT for a PUT
    46494645                {
    46504646                    if ( r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_CMD )
    … …  
    48664862        // The FSM takes the lock protecting the TRT, and the corresponding
    48674863        // entry is erased. If an acknowledge was required (in case of software SYNC)
    4868         // the r_config_rsp_lines counter is decremented. 
     4864        // the r_config_rsp_lines counter is decremented.
    48694865        //
    48704866        // - A response to a GET request is a multi-cell VCI packet.
    … …  
    48734869        // The FSM takes the lock protecting the TRT to store the line in the TRT
    48744870        // (taking into account the write requests already stored in the TRT).
    4875         // When the line is completely written, the r_ixr_rsp_to_xram_rsp_rok[index] 
     4871        // When the line is completely written, the r_ixr_rsp_to_xram_rsp_rok[index]
    48764872        // signal is set to inform the XRAM_RSP FSM.
    48774873        ///////////////////////////////////////////////////////////////////////////////
    … …  
    49024898                                    << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
    49034899#endif
    4904                         }     
    4905                     } 
     4900                        }
     4901                    }
    49064902                    break;
    49074903                }
    … …  
    49194915                    if(r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
    49204916                    {
    4921                         size_t  index = r_ixr_rsp_trt_index.read(); 
     4917                        size_t  index = r_ixr_rsp_trt_index.read();
    49224918                        if (m_trt.is_config(index))     // it's a config transaction
    49234919                        {
    … …  
    49774973        // The cache line has been written in the TRT by the IXR_CMD_FSM.
    49784974        // As the IXR_RSP FSM and the XRAM_RSP FSM are running in parallel,
    4979         // there is as many flip-flops r_ixr_rsp_to_xram_rsp_rok[i] as the number 
     4975        // there is as many flip-flops r_ixr_rsp_to_xram_rsp_rok[i] as the number
    49804976        // of entries in the TRT, that are handled with a round-robin priority...
    49814977        //
    … …  
    50185014                            break;
    50195015                        }
    5020                     } 
     5016                    }
    50215017                    break;
    50225018                }
    … …  
    50745070                    r_xram_rsp_victim_inval     = inval ;
    50755071                    // a NCC line is by default considered as dirty in the L1: we must take a reservation on a TRT entry
    5076                     r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1)); 
     5072                    r_xram_rsp_victim_dirty     = victim.dirty or (!victim.cache_coherent && (victim.count == 1));
    50775073
    50785074
    50795075                    // A line that undergoes a change in its state (ncc to cc), should not be evicted from the memory cache.
    5080                     if((victim.tag * m_sets + set) == r_read_to_cleanup_nline.read() and r_read_to_cleanup_req.read()) 
     5076                    if((victim.tag * m_sets + set) == r_read_to_cleanup_nline.read() and r_read_to_cleanup_req.read())
    50815077                    {
    50825078                        r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    … …  
    50905086#endif
    50915087                    }
    5092                     else if( not r_xram_rsp_trt_buf.rerror ) 
     5088                    else if( not r_xram_rsp_trt_buf.rerror )
    50935089                    {
    50945090                        r_xram_rsp_fsm = XRAM_RSP_IVT_LOCK;
    50955091                    }
    5096                     else 
     5092                    else
    50975093                    {
    50985094                        r_xram_rsp_fsm = XRAM_RSP_ERROR_ERASE;
    … …  
    51115107                }
    51125108                ///////////////////////
    5113             case XRAM_RSP_IVT_LOCK:   // Keep DIR and TRT locks and take the IVT lock 
     5109            case XRAM_RSP_IVT_LOCK:   // Keep DIR and TRT locks and take the IVT lock
    51145110                // to check a possible pending inval
    51155111                {
    … …  
    52415237                        bool   wok = m_ivt.set(false,      // it's an inval transaction
    52425238                                broadcast,  // set broadcast bit
    5243                                 false,      // no response required 
    5244                                 false,      // no acknowledge required 
     5239                                false,      // no response required
     5240                                false,      // no acknowledge required
    52455241                                0,          // srcid
    52465242                                0,          // trdid
    … …  
    52525248                        r_xram_rsp_ivt_index = index;
    52535249                        assert( wok and
    5254                                 "MEMC ERROR in XRAM_RSP_DIR_UPDT state: IVT should not be full"); 
     5250                                "MEMC ERROR in XRAM_RSP_DIR_UPDT state: IVT should not be full");
    52555251
    52565252                    }
    … …  
    53135309                                0,                                 // unused
    53145310                                0,                                 // unused
    5315                                 std::vector<be_t>(m_words,0xF),                         
     5311                                std::vector<be_t>(m_words,0xF),
    53165312                                data_vector);
    53175313#if DEBUG_MEMC_XRAM_RSP
    … …  
    54115407                        m_cpt_write_dirty++;
    54125408
    5413                         bool multi_req = not r_xram_rsp_victim_is_cnt.read() and 
     5409                        bool multi_req = not r_xram_rsp_victim_is_cnt.read() and
    54145410                            r_xram_rsp_victim_inval.read();
    54155411                        bool not_last_multi_req = multi_req and (r_xram_rsp_victim_count.read() != 1);
    … …  
    55405536                        // acknowledged before signaling another one.
    55415537                        // Therefore, when there is an active error, and other
    5542                         // errors arrive, these are not considered 
     5538                        // errors arrive, these are not considered
    55435539
    55445540                        if (!r_xram_rsp_rerror_irq.read() && r_xram_rsp_rerror_irq_enable.read()
    … …  
    56395635                    r_cleanup_inst  = (type == DspinRwtParam::TYPE_CLEANUP_INST);
    56405636                    r_cleanup_srcid = srcid;
    5641                     r_cleanup_ncc = 
     5637                    r_cleanup_ncc =
    56425638                        DspinRwtParam::dspin_get(
    56435639                                flit,
    … …  
    57385734                        uint64_t flit = m_cc_receive_to_cleanup_fifo.read();
    57395735
    5740                         uint32_t data = 
     5736                        uint32_t data =
    57415737                            DspinRwtParam::dspin_get (flit, DspinRwtParam::CLEANUP_DATA_UPDT);
    57425738
    … …  
    58095805                    //RWT
    58105806                    size_t set = m_y[(addr_t)(cleanup_address)];
    5811                     m_cache_data.read_line(way, set, r_cleanup_old_data); 
     5807                    m_cache_data.read_line(way, set, r_cleanup_old_data);
    58125808                    r_cleanup_coherent = entry.cache_coherent;
    58135809
    … …  
    59115907                    entry.lock           = r_cleanup_lock.read();
    59125908                    entry.ptr            = r_cleanup_ptr.read();
    5913                     if (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) //pending READ 
     5909                    if (r_read_to_cleanup_req.read() and (r_cleanup_nline.read() == r_read_to_cleanup_nline.read())) //pending READ
    59145910                    {
    59155911                        if (r_read_to_cleanup_cached_read.read())
    … …  
    59375933
    59385934#if REVERT_CC_MECANISM
    5939                         // Revert CC to NCC if : 
     5935                        // Revert CC to NCC if :
    59405936                        //  - no more copy in L1 caches
    59415937                        //  - this line is not in counter mode (broadcast)
    … …  
    59485944
    59495945#if REVERT_BC_MECANISM
    5950                         if ((r_cleanup_count.read() - 1) == 0) 
     5946                        if ((r_cleanup_count.read() - 1) == 0)
    59515947                        {
    59525948                            entry.is_cnt = false;
    … …  
    60826078                        {
    60836079                            r_cleanup_to_tgt_rsp_data[i] = r_cleanup_old_data[i].read();
    6084                         }       
     6080                        }
    60856081                    }
    60866082
    … …  
    63546350                //////////////////////
    63556351            case CLEANUP_IVT_LOCK:   // get the lock protecting the IVT to search a pending
    6356                 // invalidate transaction matching the cleanup 
     6352                // invalidate transaction matching the cleanup
    63576353                {
    63586354                    if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    … …  
    64326428                }
    64336429                ///////////////////////
    6434             case CLEANUP_IVT_CLEAR:    // Clear IVT entry 
     6430            case CLEANUP_IVT_CLEAR:    // Clear IVT entry
    64356431                {
    64366432                    assert( (r_alloc_ivt_fsm.read() == ALLOC_IVT_CLEANUP) and
    … …  
    64736469                    r_cleanup_to_tgt_rsp_trdid   = r_cleanup_write_trdid.read();
    64746470                    r_cleanup_to_tgt_rsp_pktid   = r_cleanup_write_pktid.read();
    6475                     r_cleanup_to_tgt_rsp_type    = true; 
     6471                    r_cleanup_to_tgt_rsp_type    = true;
    64766472
    64776473                    if (r_cleanup_ncc.read() )
    … …  
    65036499                        {
    65046500                            size_t index = 0;
    6505                             bool   hit   = m_trt.hit_write(r_cleanup_nline.read(), &index); 
     6501                            bool   hit   = m_trt.hit_write(r_cleanup_nline.read(), &index);
    65066502
    65076503                            assert (hit and "CLEANUP_IXR_REQ found no matching entry in TRT");
    … …  
    65106506
    65116507                            if (r_cleanup_contains_data.read())
    6512                             { 
     6508                            {
    65136509                                std::vector<data_t> data_vector;
    65146510                                data_vector.clear();
    … …  
    65876583                            << " nline = "   << std::hex << r_cleanup_nline.read()
    65886584                            << " / way = "   << std::dec << r_cleanup_way.read()
    6589                             << " / srcid = " << std::dec << r_cleanup_srcid.read() 
     6585                            << " / srcid = " << std::dec << r_cleanup_srcid.read()
    65906586                            << std::endl;
    65916587#endif
    … …  
    68056801                            if(m_debug)
    68066802                                std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE>"
    6807                                     << " Broacast Inval required" 
     6803                                    << " Broacast Inval required"
    68086804                                    << " / copies = " << r_cas_count.read() << std::endl;
    68096805#endif
    … …  
    68176813                            if(m_debug)
    68186814                                std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE>"
    6819                                     << " Multi Inval required" 
     6815                                    << " Multi Inval required"
    68206816                                    << " / copies = " << r_cas_count.read() << std::endl;
    68216817#endif
    … …  
    68746870                        wok = m_upt.set(true,    // it's an update transaction
    68756871                                false,   // it's not a broadcast
    6876                                 true,    // response required 
     6872                                true,    // response required
    68776873                                false,   // no acknowledge required
    68786874                                srcid,
    … …  
    71377133                    {
    71387134                        if(i == word)                                        // first modified word
    7139                             data_vector.push_back( r_cas_wdata.read() );     
     7135                            data_vector.push_back( r_cas_wdata.read() );
    71407136                        else if((i == word+1) and (r_cas_cpt.read() == 4))   // second modified word
    71417137                            data_vector.push_back( m_cmd_cas_wdata_fifo.read() );
    … …  
    71447140                    }
    71457141                    m_trt.set( r_cas_trt_index.read(),
    7146                             false,    // PUT request 
     7142                            false,    // PUT request
    71477143                            m_nline[(addr_t)(m_cmd_cas_addr_fifo.read())],
    71487144                            0,
    … …  
    73647360        //
    73657361        // It implements a round-robin priority between the four possible client FSMs
    7366         //     XRAM_RSP > CAS > READ > WRITE > CONFIG 
     7362        //     XRAM_RSP > CAS > READ > WRITE > CONFIG
    73677363        //
    73687364        // Each FSM can request the next services:
    … …  
    73757371        // - r_config_to_cc_send_multi_req : multi-inval
    73767372        //   r_config_to_cc_send_brdcast_req : broadcast-inval
    7377         //   
     7373        //
    73787374        // An inval request is a double DSPIN flit command containing:
    73797375        // 1. the index of the line to be invalidated.
    … …  
    75177513                }
    75187514                ///////////////////////////
    7519             case CC_SEND_READ_IDLE: 
     7515            case CC_SEND_READ_IDLE:
    75207516                {
    75217517                    // WRITE
    … …  
    82648260                    }
    82658261                    else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    8266                     else if(r_cleanup_to_tgt_rsp_req) 
     8262                    else if(r_cleanup_to_tgt_rsp_req)
    82678263                    {
    82688264                        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    … …  
    88098805        // - The XRAM_RSP FSM initiates broadcast/multicast invalidate transaction and sets
    88108806        //   a new entry in the IVT
    8811         // - The CONFIG FSM does the same thing as the XRAM_RSP FSM 
     8807        // - The CONFIG FSM does the same thing as the XRAM_RSP FSM
    88128808        // - The CLEANUP FSM complete those trasactions and erase the IVT entry.
    88138809        // The resource is always allocated.
    … …  
    88448840                //////////////////////////
    88458841            case ALLOC_IVT_READ:            // allocated to READ FSM
    8846                 if (r_read_fsm.read() != READ_IVT_LOCK) 
     8842                if (r_read_fsm.read() != READ_IVT_LOCK)
    88478843                {
    88488844                    if (r_xram_rsp_fsm.read() == XRAM_RSP_IVT_LOCK)
    … …  
    92319227                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    92329228
    9233                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9229                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    92349230                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    92359231
    … …  
    92689264                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    92699265
    9270                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9266                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    92719267                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    92729268
    … …  
    93049300                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    93059301
    9306                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9302                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    93079303                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    93089304
    … …  
    93389334                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    93399335
    9340                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9336                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    93419337                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    93429338
    … …  
    93699365                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    93709366
    9371                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9367                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    93729368                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    93739369
    … …  
    94049400                        (r_ixr_rsp_fsm.read() != IXR_RSP_TRT_READ))
    94059401                {
    9406                     if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9402                    if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    94079403                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    94089404
    … …  
    95069502                        r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    95079503
    9508                     else if( r_config_fsm.read() == CONFIG_TRT_LOCK ) 
     9504                    else if( r_config_fsm.read() == CONFIG_TRT_LOCK )
    95099505                        r_alloc_trt_fsm = ALLOC_TRT_CONFIG;
    95109506                }
    … …  
    96989694        /////////////////////////////////////////////////////////////////////
    96999695
    9700         m_cmd_read_addr_fifo.update(   cmd_read_fifo_get, cmd_read_fifo_put, 
     9696        m_cmd_read_addr_fifo.update(   cmd_read_fifo_get, cmd_read_fifo_put,
    97019697                p_vci_tgt.address.read() );
    9702         m_cmd_read_length_fifo.update( cmd_read_fifo_get, cmd_read_fifo_put, 
     9698        m_cmd_read_length_fifo.update( cmd_read_fifo_get, cmd_read_fifo_put,
    97039699                p_vci_tgt.plen.read()>>2 );
    9704         m_cmd_read_srcid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put, 
     9700        m_cmd_read_srcid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
    97059701                p_vci_tgt.srcid.read() );
    9706         m_cmd_read_trdid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put, 
     9702        m_cmd_read_trdid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
    97079703                p_vci_tgt.trdid.read() );
    9708         m_cmd_read_pktid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put, 
     9704        m_cmd_read_pktid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
    97099705                p_vci_tgt.pktid.read() );
    97109706
    … …  
    97739769
    97749770        m_cc_receive_to_multi_ack_fifo.update( cc_receive_to_multi_ack_fifo_get,
    9775                 cc_receive_to_multi_ack_fifo_put, 
     9771                cc_receive_to_multi_ack_fifo_put,
    97769772                p_dspin_p2m.data.read() );
    97779773
    … …  
    98179813        // The three sources of (increment / decrement) are CONFIG / CLEANUP / IXR_RSP FSMs
    98189814        ////////////////////////////////////////////////////////////////////////////////////
    9819         if ( config_rsp_lines_incr and not 
     9815        if ( config_rsp_lines_incr and not
    98209816             (config_rsp_lines_cleanup_decr or config_rsp_lines_ixr_rsp_decr) )
    98219817        {
    98229818            r_config_rsp_lines = r_config_rsp_lines.read() + 1;
    98239819        }
    9824         if ( not config_rsp_lines_incr and 
     9820        if ( not config_rsp_lines_incr and
    98259821             (config_rsp_lines_cleanup_decr or config_rsp_lines_ixr_rsp_decr) )
    98269822        {
    … …  
    98309826        ////////////////////////////////////////////////////////////////////////////////////
    98319827        //            Update min m_cpt_heap_min_slot_available.
    9832         // The four sources of (increment / decrement) are READ / CLEANUP / XRAM_RSP / CONFIG FSMs 
     9828        // The four sources of (increment / decrement) are READ / CLEANUP / XRAM_RSP / CONFIG FSMs
    98339829        ////////////////////////////////////////////////////////////////////////////////////
    98349830        assert((m_cpt_heap_slot_available <= m_heap_size) and "m_cpt_heap_slot_available > m_heap_size");
    … …  
    98689864        // DATA width is 8 bytes
    98699865        // The following values are not transmitted to XRAM
    9870         //   p_vci_ixr.be 
    9871         //   p_vci_ixr.pktid 
    9872         //   p_vci_ixr.cons 
    9873         //   p_vci_ixr.wrap 
    9874         //   p_vci_ixr.contig 
    9875         //   p_vci_ixr.clen 
    9876         //   p_vci_ixr.cfixed 
     9866        //   p_vci_ixr.be
     9867        //   p_vci_ixr.pktid
     9868        //   p_vci_ixr.cons
     9869        //   p_vci_ixr.wrap
     9870        //   p_vci_ixr.contig
     9871        //   p_vci_ixr.clen
     9872        //   p_vci_ixr.cfixed
    98779873
    98789874        p_vci_ixr.plen    = 64;
    … …  
    98809876        p_vci_ixr.trdid   = r_ixr_cmd_trdid.read();
    98819877        p_vci_ixr.address = (addr_t)r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2);
    9882         p_vci_ixr.be      = 0xFF; 
     9878        p_vci_ixr.be      = 0xFF;
    98839879        p_vci_ixr.pktid   = 0;
    98849880        p_vci_ixr.cons    = false;
    … …  
    99169912            p_vci_ixr.cmdval  = true;
    99179913            p_vci_ixr.address = (addr_t)r_ixr_cmd_address.read() + (r_ixr_cmd_word.read()<<2);
    9918             p_vci_ixr.wdata   = ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read()].read()) | 
     9914            p_vci_ixr.wdata   = ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read()].read()) |
    99199915                    ((wide_data_t)(r_ixr_cmd_wdata[r_ixr_cmd_word.read() + 1].read()) << 32));
    99209916            p_vci_ixr.trdid   = r_cleanup_to_ixr_cmd_index.read();
    … …  
    99339929        if( (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ) or
    99349930                (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) )
    9935         { 
     9931        {
    99369932            p_vci_ixr.rspack = (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP);
    99379933        }
    … …  
    1010910105                    p_vci_tgt.rspval  = true;
    1011010106
    10111                     if( is_ll and not r_tgt_rsp_key_sent.read() ) 
     10107                    if( is_ll and not r_tgt_rsp_key_sent.read() )
    1011210108                    {
    1011310109                        // LL response first flit
    1011410110                        p_vci_tgt.rdata = r_xram_rsp_to_tgt_rsp_ll_key.read();
    1011510111                    }
    10116                     else 
     10112                    else
    1011710113                    {
    1011810114                        // LL response second flit or READ response
    … …  
    1027510271                            m_broadcast_boundaries,
    1027610272                            DspinRwtParam::BROADCAST_BOX);
    10277                    
     10273
    1027810274                    DspinRwtParam::dspin_set( flit,
    1027910275                            1,
Note: See TracChangeset for help on using the changeset viewer.