Changeset 313 for branches


Ignore:
Timestamp:
Mar 12, 2013, 3:20:33 PM (12 years ago)
Author:
cfuguet
Message:

Erasing useless template parameters for the communication/dspin_dhccp_param class.

Modifying consequently the vci_mem_cache_dspin_coherence class to use the
dspin_dhccp_param class without templates.

Introducing in the vci_mem_cache and the vci_mem_cache_dspin_coherence modules
the state CAS_DIR_HIT_COMPARE.

Before this modification, the comparison between the expected data and the actual
data was done directly in the CAS_DIR_HIT_READ state using the data obtained in the
same cycle from the cache.

Now, the data obtained from the cache is stored in a buffer and the next cycle,
in the CAS_DIR_HIT_COMPARE state, the comparison is made using the data from the
buffer.

This modifications allows to eliminate a critical path obtained in the ASIC
synthesis of the memory cache.

Location:
branches/v5
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • branches/v5/communication/dspin_dhccp_param/caba/metadata/dspin_dhccp_param.sd

    r307 r313  
    11Module('caba:dspin_dhccp_param',
    22           classname = 'soclib::caba::DspinDhccpParam',
    3            tmpl_parameters = [
    4                 parameter.Int('from_mc_flit_width_t'),
    5                 parameter.Int('from_l1_flit_width_t'),
    6                 ],
    73           header_files = ['../source/include/dspin_dhccp_param.h',]
    84)

  • branches/v5/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h

    r312 r313  
     1/* -*- c++ -*-
     2 * File         : dspin_dhccp_param.h
     3 * Date         : 01/03/2013
     4 * Copyright    : UPMC / LIP6
     5 * Authors      : Cesar Fuguet
     6 *
     7 * SOCLIB_LGPL_HEADER_BEGIN
     8 *
     9 * This file is part of SoCLib, GNU LGPLv2.1.
     10 *
     11 * SoCLib is free software; you can redistribute it and/or modify it
     12 * under the terms of the GNU Lesser General Public License as published
     13 * by the Free Software Foundation; version 2.1 of the License.
     14 *
     15 * SoCLib is distributed in the hope that it will be useful, but
     16 * WITHOUT ANY WARRANTY; without even the implied warranty of
     17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     18 * Lesser General Public License for more details.
     19 *
     20 * You should have received a copy of the GNU Lesser General Public
     21 * License along with SoCLib; if not, write to the Free Software
     22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     23 * 02110-1301 USA
     24 *
     25 * SOCLIB_LGPL_HEADER_END
     26 */
     27
     28
    129#ifndef DSPIN_DHCCP_PARAMS_H
    230#define DSPIN_DHCCP_PARAMS_H
    … …  
    101129    case z: x |= ((y & z##_MASK) << z##_SHIFT);break
    102130
    103 template<int from_memc_flit_width_t, int from_l1_flit_width_t>
    104131class DspinDhccpParam
    105132{

  • branches/v5/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r295 r313  
    215215        CAS_DIR_LOCK,
    216216        CAS_DIR_HIT_READ,
     217        CAS_DIR_HIT_COMPARE,
    217218        CAS_DIR_HIT_WRITE,
    218219        CAS_UPT_LOCK,
    … …  
    660661      sc_signal<size_t>   r_cas_trt_index;  // Transaction Table index
    661662      sc_signal<size_t>   r_cas_upt_index;  // Update Table index
     663      sc_signal<data_t> * r_cas_data;       // cache line data
    662664
    663665      // Buffer between CAS fsm and INIT_CMD fsm (XRAM read)

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

    r305 r313  
    175175    "CAS_DIR_LOCK",
    176176    "CAS_DIR_HIT_READ",
     177    "CAS_DIR_HIT_COMPARE",
    177178    "CAS_DIR_HIT_WRITE",
    178179    "CAS_UPT_LOCK",
    … …  
    434435
    435436      // Allocation for CAS FSM
    436       r_cas_to_ixr_cmd_data        = new sc_signal<data_t>[nwords];
    437       r_cas_rdata                  = new sc_signal<data_t>[2];
    438 
     437      r_cas_to_ixr_cmd_data       = new sc_signal<data_t>[nwords];
     438      r_cas_data                  = new sc_signal<data_t>[nwords];
     439      r_cas_rdata                 = new sc_signal<data_t>[2];
    439440
    440441      // Simulation
    … …  
    43284329            if( r_alloc_dir_fsm.read() == ALLOC_DIR_CAS )
    43294330            {
    4330               r_cas_fsm = CAS_DIR_LOCK;
     4331                r_cas_fsm = CAS_DIR_LOCK;
    43314332            }
    43324333
    … …  
    43344335            if( m_debug_cas_fsm )
    43354336            {
    4336               std::cout
    4337                 << "  <MEMC " << name() << ".CAS_DIR_REQ> Requesting DIR lock "
    4338                 << std::endl;
     4337                std::cout
     4338                    << "  <MEMC " << name() << ".CAS_DIR_REQ> Requesting DIR lock "
     4339                    << std::endl;
    43394340            }
    43404341#endif
    … …  
    43634364
    43644365                if ( entry.valid )  r_cas_fsm = CAS_DIR_HIT_READ;
    4365                 else          r_cas_fsm = CAS_MISS_TRT_LOCK;
     4366                else                r_cas_fsm = CAS_MISS_TRT_LOCK;
    43664367
    43674368#if DEBUG_MEMC_CAS
    … …  
    43784379            else
    43794380            {
    4380               std::cout
    4381                 << "VCI_MEM_CACHE ERROR " << name()
    4382                 << " CAS_DIR_LOCK state" << std::endl
    4383                 << "Bad DIR allocation"   << std::endl;
    4384 
    4385               exit(0);
     4381                std::cout
     4382                    << "VCI_MEM_CACHE ERROR " << name()
     4383                    << " CAS_DIR_LOCK state" << std::endl
     4384                    << "Bad DIR allocation"   << std::endl;
     4385
     4386                exit(0);
    43864387            }
    43874388
    43884389            break;
    43894390        }
     4391
    43904392        /////////////////////
    43914393        case CAS_DIR_HIT_READ:  // update directory for lock and dirty bit
    4392                                // and check data change in cache
     4394                                // and check data change in cache
    43934395        {
    43944396            size_t way  = r_cas_way.read();
    43954397            size_t set  = m_y[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    4396             size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    43974398
    43984399            // update directory (lock & dirty bits)
    … …  
    44024403            entry.dirty          = true;
    44034404            entry.lock           = true;
    4404             entry.tag          = r_cas_tag.read();
     4405            entry.tag            = r_cas_tag.read();
    44054406            entry.owner.srcid    = r_cas_copy.read();
    44064407#if L1_MULTI_CACHE
    … …  
    44134414            m_cache_directory.write(set, way, entry);
    44144415
    4415             // read data in cache & check data change
    4416             bool ok = ( r_cas_rdata[0].read() == m_cache_data.read(way, set, word) );
    4417             if ( r_cas_cpt.read()==4 )  // 64 bits CAS
    4418                 ok &= ( r_cas_rdata[1] == m_cache_data.read(way, set, word+1));
     4416            // Stored data from cache in buffer to do the comparison in next state
     4417            m_cache_data.read_line(way, set, r_cas_data);
     4418
     4419            r_cas_fsm = CAS_DIR_HIT_COMPARE;
     4420
     4421#if DEBUG_MEMC_CAS
     4422            if(m_debug_cas_fsm)
     4423            {
     4424                std::cout << "  <MEMC " << name() << ".CAS_DIR_HIT_READ> Read data from "
     4425                    << " cache and store it in buffer"
     4426                    << std::endl;
     4427            }
     4428#endif
     4429            break;
     4430        }
     4431
     4432        case CAS_DIR_HIT_COMPARE:
     4433        {
     4434            size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
     4435
     4436            // Read data in buffer & check data change
     4437            bool ok = (r_cas_rdata[0].read() == r_cas_data[word].read());
     4438
     4439            if(r_cas_cpt.read() == 4)     // 64 bits CAS
     4440                ok &= (r_cas_rdata[1] == r_cas_data[word+1]);
    44194441
    44204442            // to avoid livelock, force the atomic access to fail pseudo-randomly
    4421             bool forced_fail = ( (r_cas_lfsr % (64) == 0) && RANDOMIZE_CAS );
    4422             r_cas_lfsr = (r_cas_lfsr >> 1) ^ ((-(r_cas_lfsr & 1)) & 0xd0000001);
    4423 
    4424             if( ok and not forced_fail )  // no data change
     4443            bool forced_fail = ((r_cas_lfsr % (64) == 0) && RANDOMIZE_CAS);
     4444            r_cas_lfsr = (r_cas_lfsr >> 1) ^ ((- (r_cas_lfsr & 1)) & 0xd0000001);
     4445
     4446            // cas success
     4447            if(ok and not forced_fail)
    44254448            {
    44264449                r_cas_fsm = CAS_DIR_HIT_WRITE;
    44274450            }
    4428             else                            // return failure
     4451            // cas failure
     4452            else
    44294453            {
    44304454                r_cas_fsm = CAS_RSP_FAIL;
    … …  
    44324456
    44334457#if DEBUG_MEMC_CAS
    4434 if( m_debug_cas_fsm )
    4435 {
    4436     std::cout << "  <MEMC " << name() << ".CAS_DIR_HIT_READ> Test if CAS success:"
    4437               << " / expected value = " << r_cas_rdata[0].read()
    4438               << " / actual value = " << m_cache_data.read(way, set, word)
    4439               << " / forced_fail = " << forced_fail << std::endl;
    4440 }
     4458            if(m_debug_cas_fsm)
     4459            {
     4460                std::cout << "  <MEMC " << name() << ".CAS_DIR_HIT_COMPARE> Compare the old"
     4461                    << " and the new data"
     4462                    << " / expected value = " << r_cas_rdata[0].read()
     4463                    << " / actual value = "   << r_cas_data[word].read()
     4464                    << " / forced_fail = "    << forced_fail << std::endl;
     4465            }
    44414466#endif
    44424467            break;
    44434468        }
     4469
    44444470        //////////////////////
    44454471        case CAS_DIR_HIT_WRITE:    // test if a CC transaction is required
    … …  
    44774503                    m_cache_data.write(way, set, word+1, m_cmd_cas_wdata_fifo.read());
    44784504
     4505                r_cas_fsm = CAS_RSP_SUCCESS;
     4506
    44794507                // monitor
    44804508                if ( m_monitor_ok )
    44814509                {
    44824510                    vci_addr_t address = m_cmd_cas_addr_fifo.read();
    4483                 char buf[80];
    4484                 snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d", m_cmd_cas_srcid_fifo.read());
     4511
     4512                    char buf[80];
     4513                    snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d",
     4514                             m_cmd_cas_srcid_fifo.read());
     4515
    44854516                    check_monitor( buf, address, r_cas_wdata.read() );
    44864517                    if ( r_cas_cpt.read()==4 )
    44874518                    check_monitor( buf, address+4, m_cmd_cas_wdata_fifo.read() );
    44884519                }
    4489                 r_cas_fsm = CAS_RSP_SUCCESS;
    44904520
    44914521#if DEBUG_MEMC_CAS
    … …  
    47044734                {
    47054735                    // fill the data buffer
    4706                     size_t way  = r_cas_way.read();
    4707                     size_t set  = m_y[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    4708                         size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
     4736                    size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    47094737                    for(size_t i = 0; i<m_words; i++)
    47104738                    {
    … …  
    47194747                        else
    47204748                        {
    4721                             r_cas_to_ixr_cmd_data[i] = m_cache_data.read(way, set, i);
     4749                            r_cas_to_ixr_cmd_data[i] = r_cas_data[i].read();
    47224750                        }
    47234751                    }
    … …  
    58225850        ////////////////////
    58235851        case ALLOC_DIR_CAS:
    5824         if ((( r_cas_fsm.read()        != CAS_DIR_REQ       )  &&
    5825              ( r_cas_fsm.read()        != CAS_DIR_LOCK      )  &&
    5826              ( r_cas_fsm.read()        != CAS_DIR_HIT_READ  )  &&
    5827              ( r_cas_fsm.read()        != CAS_DIR_HIT_WRITE )  &&
    5828              ( r_cas_fsm.read()        != CAS_BC_TRT_LOCK   )  &&
    5829              ( r_cas_fsm.read()        != CAS_BC_UPT_LOCK   )  &&
    5830              ( r_cas_fsm.read()        != CAS_MISS_TRT_LOCK )  &&
    5831              ( r_cas_fsm.read()        != CAS_UPT_LOCK      )  &&
    5832              ( r_cas_fsm.read()        != CAS_UPT_HEAP_LOCK ))
     5852        if ((( r_cas_fsm.read()        != CAS_DIR_REQ         )  &&
     5853             ( r_cas_fsm.read()        != CAS_DIR_LOCK        )  &&
     5854             ( r_cas_fsm.read()        != CAS_DIR_HIT_READ    )  &&
     5855             ( r_cas_fsm.read()        != CAS_DIR_HIT_COMPARE )  &&
     5856             ( r_cas_fsm.read()        != CAS_DIR_HIT_WRITE   )  &&
     5857             ( r_cas_fsm.read()        != CAS_BC_TRT_LOCK     )  &&
     5858             ( r_cas_fsm.read()        != CAS_BC_UPT_LOCK     )  &&
     5859             ( r_cas_fsm.read()        != CAS_MISS_TRT_LOCK   )  &&
     5860             ( r_cas_fsm.read()        != CAS_UPT_LOCK        )  &&
     5861             ( r_cas_fsm.read()        != CAS_UPT_HEAP_LOCK   ))
    58335862            ||
    5834             (( r_cas_fsm.read()        == CAS_UPT_HEAP_LOCK )  &&
    5835              ( r_alloc_heap_fsm.read() == ALLOC_HEAP_CAS    ))
     5863            (( r_cas_fsm.read()        == CAS_UPT_HEAP_LOCK   )  &&
     5864             ( r_alloc_heap_fsm.read() == ALLOC_HEAP_CAS      ))
    58365865            ||
    5837             (( r_cas_fsm.read()        == CAS_MISS_TRT_LOCK )  &&
    5838              ( r_alloc_trt_fsm.read()  == ALLOC_TRT_CAS     )))
     5866            (( r_cas_fsm.read()        == CAS_MISS_TRT_LOCK   )  &&
     5867             ( r_alloc_trt_fsm.read()  == ALLOC_TRT_CAS       )))
    58395868        {
    58405869          if ( r_cleanup_fsm.read() == CLEANUP_DIR_REQ )

  • branches/v5/modules/vci_mem_cache_dspin_coherence/caba/metadata/vci_mem_cache.sd

    r309 r313  
    99
    1010        tmpl_parameters = [
    11                         parameter.Module('vci_param'  , default = 'caba:vci_param'),
    12                         parameter.Int('from_mc_flit_width', default = 40),
    13                         parameter.Int('from_l1_flit_width', default = 33)
     11                        parameter.Module('vci_param'  , default = 'caba:vci_param')
    1412                ],
    1513
    … …  
    2927            Uses('caba:generic_fifo'),
    3028            Uses('caba:generic_llsc_global_table'),
    31                         Uses(
    32                           'caba:dspin_dhccp_param',
    33                           from_mc_flit_width_t = parameter.Reference('from_mc_flit_width'),
    34                           from_l1_flit_width_t = parameter.Reference('from_l1_flit_width'),
    35                           ),
     29                        Uses('caba:dspin_dhccp_param')
    3630        ],
    3731
    … …  
    4135                                'caba:dspin_input',
    4236                                'p_dspin_in',
    43                                 dspin_data_size = parameter.Reference('from_l1_flit_width'),
     37                                dspin_data_size = 33,
    4438                        ),
    4539                        Port(
    4640                                'caba:dspin_output',
    4741                                'p_dspin_out',
    48                                 dspin_data_size = parameter.Reference('from_mc_flit_width'),
     42                                dspin_data_size = 40,
    4943                        ),
    5044            Port( 'caba:vci_initiator', 'p_vci_ixr' ),

  • branches/v5/modules/vci_mem_cache_dspin_coherence/caba/source/include/vci_mem_cache.h

    r307 r313  
    5858  using namespace sc_core;
    5959
    60   template<typename vci_param, int from_mc_flit_width, int from_l1_flit_width>
     60  template<typename vci_param>
    6161    class VciMemCache
    6262    : public soclib::caba::BaseModule
    … …  
    6969      typedef uint32_t be_t;
    7070      typedef uint32_t copy_t;
    71 
    72       typedef soclib::caba::DspinDhccpParam
    73         <from_mc_flit_width
    74         ,from_l1_flit_width> dspin_param;
    7571
    7672      /* States of the TGT_CMD fsm */
    … …  
    225221        CAS_DIR_LOCK,
    226222        CAS_DIR_HIT_READ,
     223        CAS_DIR_HIT_COMPARE,
    227224        CAS_DIR_HIT_WRITE,
    228225        CAS_UPT_LOCK,
    … …  
    383380      soclib::caba::VciInitiator<vci_param> p_vci_ixr;
    384381
    385       soclib::caba::DspinInput <from_l1_flit_width> p_dspin_in;
    386       soclib::caba::DspinOutput<from_mc_flit_width> p_dspin_out;
     382      soclib::caba::DspinInput<33>          p_dspin_in;
     383      soclib::caba::DspinOutput<40>        p_dspin_out;
    387384
    388385      VciMemCache(
    … …  
    690687      sc_signal<size_t>   r_cas_trt_index;  // Transaction Table index
    691688      sc_signal<size_t>   r_cas_upt_index;  // Update Table index
     689      sc_signal<data_t> * r_cas_data;       // cache line data
    692690
    693691      // Buffer between CAS fsm and IXR_CMD fsm (XRAM write)

  • branches/v5/modules/vci_mem_cache_dspin_coherence/caba/source/src/vci_mem_cache.cpp

    r310 r313  
    196196  "CAS_DIR_LOCK",
    197197  "CAS_DIR_HIT_READ",
     198  "CAS_DIR_HIT_COMPARE",
    198199  "CAS_DIR_HIT_WRITE",
    199200  "CAS_UPT_LOCK",
    … …  
    267268
    268269#define tmpl(x) \
    269   template<typename vci_param, int from_mc_flit_width, int from_l1_flit_width> x \
    270   VciMemCache<vci_param, from_mc_flit_width, from_l1_flit_width>
     270  template<typename vci_param> x \
     271  VciMemCache<vci_param>
    271272
    272273using soclib::common::uint32_log2;
    … …  
    468469  r_write_data               = new sc_signal<data_t>[nwords];
    469470  r_write_be                 = new sc_signal<be_t>[nwords];
    470   r_write_to_cc_send_data  = new sc_signal<data_t>[nwords];
    471   r_write_to_cc_send_be    = new sc_signal<be_t>[nwords];
     471  r_write_to_cc_send_data    = new sc_signal<data_t>[nwords];
     472  r_write_to_cc_send_be      = new sc_signal<be_t>[nwords];
    472473  r_write_to_ixr_cmd_data    = new sc_signal<data_t>[nwords];
    473474
    474475  // Allocation for CAS FSM
    475476  r_cas_to_ixr_cmd_data      = new sc_signal<data_t>[nwords];
     477  r_cas_data                 = new sc_signal<data_t>[nwords];
    476478  r_cas_rdata                = new sc_signal<data_t>[2];
    477479
    … …  
    11041106
    11051107        uint8_t updt_index =
    1106           dspin_param::dspin_get(flit, dspin_param::MULTI_ACK_UPDT_INDEX);
     1108          DspinDhccpParam::dspin_get(flit, DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
    11071109
    11081110        bool eop =
    1109           (dspin_param::dspin_get(flit, dspin_param::FROM_L1_EOP) == 0x1);
     1111          (DspinDhccpParam::dspin_get(flit, DspinDhccpParam::FROM_L1_EOP) == 0x1);
    11101112
    11111113        if(updt_index >= m_update_tab.size())
    … …  
    37433745
    37443746      uint32_t srcid =
    3745         dspin_param::dspin_get(
     3747        DspinDhccpParam::dspin_get(
    37463748            flit,
    3747             dspin_param::CLEANUP_SRCID);
     3749            DspinDhccpParam::CLEANUP_SRCID);
    37483750
    37493751      uint8_t type =
    3750         dspin_param::dspin_get(
     3752        DspinDhccpParam::dspin_get(
    37513753            flit,
    3752             dspin_param::FROM_L1_TYPE);
     3754            DspinDhccpParam::FROM_L1_TYPE);
    37533755
    37543756      r_cleanup_way_index =
    3755         dspin_param::dspin_get(
     3757        DspinDhccpParam::dspin_get(
    37563758            flit,
    3757             dspin_param::CLEANUP_WAY_INDEX);
     3759            DspinDhccpParam::CLEANUP_WAY_INDEX);
    37583760
    37593761      r_cleanup_nline =
    3760         dspin_param::dspin_get(
     3762        DspinDhccpParam::dspin_get(
    37613763            flit,
    3762             dspin_param::CLEANUP_NLINE_MSB)
     3764            DspinDhccpParam::CLEANUP_NLINE_MSB)
    37633765        << 32;
    37643766
    3765       r_cleanup_inst  = (type == dspin_param::TYPE_CLEANUP_INST);
     3767      r_cleanup_inst  = (type == DspinDhccpParam::TYPE_CLEANUP_INST);
    37663768      r_cleanup_srcid = srcid;
    37673769
    … …  
    37873789            << ".CLEANUP_IDLE> Cleanup request:" << std::hex
    37883790            << " / owner_id = "   << srcid
    3789             << " / owner_ins = "  << (type == dspin_param::TYPE_CLEANUP_INST)
     3791            << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST)
    37903792            << std::endl;
    37913793      }
    … …  
    38033805      addr_t nline =
    38043806        r_cleanup_nline.read() |
    3805         dspin_param::dspin_get(flit, dspin_param::CLEANUP_NLINE_LSB);
     3807        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB);
    38063808
    38073809      bool eop =
    3808         dspin_param::dspin_get(flit, dspin_param::FROM_L1_EOP) == 0x1;
     3810        DspinDhccpParam::dspin_get(flit, DspinDhccpParam::FROM_L1_EOP) == 0x1;
    38093811
    38103812      assert(
    … …  
    46614663
    46624664        if(entry.valid)  r_cas_fsm = CAS_DIR_HIT_READ;
    4663         else          r_cas_fsm = CAS_MISS_TRT_LOCK;
     4665        else             r_cas_fsm = CAS_MISS_TRT_LOCK;
    46644666
    46654667#if DEBUG_MEMC_CAS
    … …  
    46884690    /////////////////////
    46894691    case CAS_DIR_HIT_READ:  // update directory for lock and dirty bit
    4690       // and check data change in cache
     4692                            // and check data change in cache
    46914693    {
    46924694      size_t way  = r_cas_way.read();
    46934695      size_t set  = m_y[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    4694       size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    46954696
    46964697      // update directory (lock & dirty bits)
    … …  
    47004701      entry.dirty          = true;
    47014702      entry.lock           = true;
    4702       entry.tag          = r_cas_tag.read();
     4703      entry.tag            = r_cas_tag.read();
    47034704      entry.owner.srcid    = r_cas_copy.read();
    47044705#if L1_MULTI_CACHE
    … …  
    47114712      m_cache_directory.write(set, way, entry);
    47124713
    4713       // read data in cache & check data change
    4714       bool ok = (r_cas_rdata[0].read() == m_cache_data.read(way, set, word));
    4715       if(r_cas_cpt.read() ==4)    // 64 bits CAS
    4716         ok &= (r_cas_rdata[1] == m_cache_data.read(way, set, word+1));
     4714      // Stored data from cache in buffer to do the comparison in next state
     4715      m_cache_data.read_line(way, set, r_cas_data);
     4716
     4717      r_cas_fsm = CAS_DIR_HIT_COMPARE;
     4718
     4719#if DEBUG_MEMC_CAS
     4720      if(m_debug_cas_fsm)
     4721      {
     4722        std::cout
     4723          << "  <MEMC " << name() << ".CAS_DIR_HIT_READ> Read data from "
     4724          << " cache and store it in buffer"
     4725          << std::endl;
     4726      }
     4727#endif
     4728      break;
     4729    }
     4730
     4731    case CAS_DIR_HIT_COMPARE:
     4732    {
     4733      size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
     4734
     4735      // Read data in buffer & check data change
     4736      bool ok = (r_cas_rdata[0].read() == r_cas_data[word].read());
     4737
     4738      if(r_cas_cpt.read() == 4)     // 64 bits CAS
     4739        ok &= (r_cas_rdata[1] == r_cas_data[word+1]);
    47174740
    47184741      // to avoid livelock, force the atomic access to fail pseudo-randomly
    47194742      bool forced_fail = ((r_cas_lfsr % (64) == 0) && RANDOMIZE_CAS);
    4720       r_cas_lfsr = (r_cas_lfsr >> 1) ^((- (r_cas_lfsr & 1)) & 0xd0000001);
    4721 
    4722       if(ok and not forced_fail)    // no data change
     4743      r_cas_lfsr = (r_cas_lfsr >> 1) ^ ((- (r_cas_lfsr & 1)) & 0xd0000001);
     4744
     4745      // cas success
     4746      if(ok and not forced_fail)
    47234747      {
    47244748        r_cas_fsm = CAS_DIR_HIT_WRITE;
    47254749      }
    4726       else                            // return failure
     4750      // cas failure
     4751      else
    47274752      {
    47284753        r_cas_fsm = CAS_RSP_FAIL;
    … …  
    47324757      if(m_debug_cas_fsm)
    47334758      {
    4734         std::cout << "  <MEMC " << name() << ".CAS_DIR_HIT_READ> Test if CAS success:"
     4759        std::cout << "  <MEMC " << name() << ".CAS_DIR_HIT_COMPARE> Compare the old"
     4760                  << " and the new data"
    47354761                  << " / expected value = " << r_cas_rdata[0].read()
    4736                   << " / actual value = " << m_cache_data.read(way, set, word)
    4737                   << " / forced_fail = " << forced_fail << std::endl;
     4762                  << " / actual value = "   << r_cas_data[word].read()
     4763                  << " / forced_fail = "    << forced_fail << std::endl;
    47384764      }
    47394765#endif
    … …  
    47724798        // cache update
    47734799        m_cache_data.write(way, set, word, r_cas_wdata.read());
    4774         if(r_cas_cpt.read() ==4)
     4800        if(r_cas_cpt.read() == 4)
    47754801          m_cache_data.write(way, set, word+1, m_cmd_cas_wdata_fifo.read());
     4802
     4803        r_cas_fsm = CAS_RSP_SUCCESS;
    47764804
    47774805        // monitor
    … …  
    47824810          snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d", m_cmd_cas_srcid_fifo.read());
    47834811          check_monitor(buf, address, r_cas_wdata.read());
    4784           if(r_cas_cpt.read() ==4)
     4812
     4813          if(r_cas_cpt.read() == 4)
    47854814            check_monitor(buf, address+4, m_cmd_cas_wdata_fifo.read());
    47864815        }
    4787         r_cas_fsm = CAS_RSP_SUCCESS;
    47884816
    47894817#if DEBUG_MEMC_CAS
    … …  
    48384866            m_cache_data.write(way, set, word+1, m_cmd_cas_wdata_fifo.read());
    48394867
     4868          r_cas_upt_index = index;
     4869          r_cas_fsm = CAS_UPT_HEAP_LOCK;
     4870
    48404871          // monitor
    48414872          if(m_monitor_ok)
    … …  
    48454876            snprintf(buf, 80, "CAS_DIR_HIT_WRITE srcid %d", m_cmd_cas_srcid_fifo.read());
    48464877            check_monitor(buf, address, r_cas_wdata.read());
     4878
    48474879            if(r_cas_cpt.read() ==4)
    48484880              check_monitor(buf, address+4, m_cmd_cas_wdata_fifo.read());
    48494881          }
    4850 
    4851           r_cas_upt_index = index;
    4852           r_cas_fsm = CAS_UPT_HEAP_LOCK;
    48534882        }
    48544883        else       //  releases the locks protecting UPT and DIR UPT full
    … …  
    50065035        {
    50075036          // fill the data buffer
    5008           size_t way  = r_cas_way.read();
    5009           size_t set  = m_y[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    50105037          size_t word = m_x[(vci_addr_t)(m_cmd_cas_addr_fifo.read())];
    50115038          for(size_t i = 0; i<m_words; i++)
    … …  
    50155042              r_cas_to_ixr_cmd_data[i] = r_cas_wdata.read();
    50165043            }
    5017             else if((i == word+1) && (r_cas_cpt.read() ==4))   // 64 bit CAS
     5044            else if((i == word+1) && (r_cas_cpt.read() == 4))   // 64 bit CAS
    50185045            {
    50195046              r_cas_to_ixr_cmd_data[i] = m_cmd_cas_wdata_fifo.read();
    … …  
    50215048            else
    50225049            {
    5023               r_cas_to_ixr_cmd_data[i] = m_cache_data.read(way, set, i);
     5050              r_cas_to_ixr_cmd_data[i] = r_cas_data[i].read();
    50245051            }
    50255052          }
    … …  
    59105937
    59115938        uint8_t type =
    5912           dspin_param::dspin_get(
     5939          DspinDhccpParam::dspin_get(
    59135940              p_dspin_in.data.read(),
    5914               dspin_param::FROM_L1_TYPE);
    5915 
    5916         if(type == dspin_param::TYPE_CLEANUP)
     5941              DspinDhccpParam::FROM_L1_TYPE);
     5942
     5943        if(type == DspinDhccpParam::TYPE_CLEANUP)
    59175944        {
    59185945          r_cc_receive_fsm = CC_RECEIVE_CLEANUP;
    … …  
    59205947        }
    59215948       
    5922         if(type == dspin_param::TYPE_MULTI_ACK)
     5949        if(type == DspinDhccpParam::TYPE_MULTI_ACK)
    59235950        {
    59245951          r_cc_receive_fsm = CC_RECEIVE_MULTI_ACK;
    … …  
    59405967
    59415968        bool eop = (
    5942             dspin_param::dspin_get(
     5969            DspinDhccpParam::dspin_get(
    59435970              p_dspin_in.data.read(),
    5944               dspin_param::FROM_L1_EOP)
     5971              DspinDhccpParam::FROM_L1_EOP)
    59455972            == 0x1);
    59465973
    … …  
    59605987
    59615988        bool eop = (
    5962             dspin_param::dspin_get(
     5989            DspinDhccpParam::dspin_get(
    59635990              p_dspin_in.data.read(),
    5964               dspin_param::FROM_L1_EOP)
     5991              DspinDhccpParam::FROM_L1_EOP)
    59655992            == 0x1);
    59665993
    … …  
    64006427      ////////////////////
    64016428    case ALLOC_DIR_READ:
    6402       if(((r_read_fsm.read()       != READ_DIR_REQ)   &&
    6403           (r_read_fsm.read()       != READ_DIR_LOCK)   &&
    6404           (r_read_fsm.read()       != READ_TRT_LOCK)   &&
    6405           (r_read_fsm.read()       != READ_HEAP_REQ))
     6429      if(((r_read_fsm.read()        != READ_DIR_REQ)   &&
     6430          (r_read_fsm.read()        != READ_DIR_LOCK)   &&
     6431          (r_read_fsm.read()        != READ_TRT_LOCK)   &&
     6432          (r_read_fsm.read()        != READ_HEAP_REQ))
    64066433          ||
    64076434          ((r_read_fsm.read()       == READ_TRT_LOCK)   &&
    … …  
    64246451      /////////////////////
    64256452    case ALLOC_DIR_WRITE:
    6426       if(((r_write_fsm.read()      != WRITE_DIR_REQ)  &&
    6427           (r_write_fsm.read()      != WRITE_DIR_LOCK)  &&
    6428           (r_write_fsm.read()      != WRITE_DIR_READ)  &&
    6429           (r_write_fsm.read()      != WRITE_DIR_HIT)  &&
    6430           (r_write_fsm.read()      != WRITE_BC_TRT_LOCK)  &&
    6431           (r_write_fsm.read()      != WRITE_BC_UPT_LOCK)  &&
    6432           (r_write_fsm.read()      != WRITE_MISS_TRT_LOCK)  &&
    6433           (r_write_fsm.read()      != WRITE_UPT_LOCK)  &&
    6434           (r_write_fsm.read()      != WRITE_UPT_HEAP_LOCK))
     6453      if(((r_write_fsm.read()       != WRITE_DIR_REQ)  &&
     6454          (r_write_fsm.read()       != WRITE_DIR_LOCK)  &&
     6455          (r_write_fsm.read()       != WRITE_DIR_READ)  &&
     6456          (r_write_fsm.read()       != WRITE_DIR_HIT)  &&
     6457          (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  &&
     6458          (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  &&
     6459          (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  &&
     6460          (r_write_fsm.read()       != WRITE_UPT_LOCK)  &&
     6461          (r_write_fsm.read()       != WRITE_UPT_HEAP_LOCK))
    64356462          ||
    64366463          ((r_write_fsm.read()      == WRITE_UPT_HEAP_LOCK)  &&
    … …  
    64566483      ////////////////////
    64576484    case ALLOC_DIR_CAS:
    6458       if(((r_cas_fsm.read()        != CAS_DIR_REQ)  &&
    6459           (r_cas_fsm.read()        != CAS_DIR_LOCK)  &&
    6460           (r_cas_fsm.read()        != CAS_DIR_HIT_READ)  &&
    6461           (r_cas_fsm.read()        != CAS_DIR_HIT_WRITE)  &&
    6462           (r_cas_fsm.read()        != CAS_BC_TRT_LOCK)  &&
    6463           (r_cas_fsm.read()        != CAS_BC_UPT_LOCK)  &&
    6464           (r_cas_fsm.read()        != CAS_MISS_TRT_LOCK)  &&
    6465           (r_cas_fsm.read()        != CAS_UPT_LOCK)  &&
    6466           (r_cas_fsm.read()        != CAS_UPT_HEAP_LOCK))
     6485      if(((r_cas_fsm.read()         != CAS_DIR_REQ)  &&
     6486          (r_cas_fsm.read()         != CAS_DIR_LOCK)  &&
     6487          (r_cas_fsm.read()         != CAS_DIR_HIT_READ)  &&
     6488          (r_cas_fsm.read()         != CAS_DIR_HIT_COMPARE)  &&
     6489          (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  &&
     6490          (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  &&
     6491          (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  &&
     6492          (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  &&
     6493          (r_cas_fsm.read()         != CAS_UPT_LOCK)  &&
     6494          (r_cas_fsm.read()         != CAS_UPT_HEAP_LOCK))
    64676495          ||
    64686496          ((r_cas_fsm.read()        == CAS_UPT_HEAP_LOCK)  &&
    … …  
    72977325        uint64_t flit = 0;
    72987326 
    7299         dspin_param::dspin_set(
     7327        DspinDhccpParam::dspin_set(
    73007328            flit,
    73017329            1ULL,
    7302             dspin_param::FROM_MC_EOP);
    7303 
    7304         dspin_param::dspin_set(
     7330            DspinDhccpParam::FROM_MC_EOP);
     7331
     7332        DspinDhccpParam::dspin_set(
    73057333            flit,
    73067334            r_cleanup_to_cc_send_srcid.read(),
    7307             dspin_param::CLEANUP_ACK_DEST);
    7308 
    7309         dspin_param::dspin_set(
     7335            DspinDhccpParam::CLEANUP_ACK_DEST);
     7336
     7337        DspinDhccpParam::dspin_set(
    73107338            flit,
    73117339            r_cleanup_to_cc_send_set_index.read(),
    7312             dspin_param::CLEANUP_ACK_SET);
    7313 
    7314         dspin_param::dspin_set(
     7340            DspinDhccpParam::CLEANUP_ACK_SET);
     7341
     7342        DspinDhccpParam::dspin_set(
    73157343            flit,
    73167344            r_cleanup_to_cc_send_way_index.read(),
    7317             dspin_param::CLEANUP_ACK_WAY);
    7318 
    7319         dspin_param::dspin_set(
     7345            DspinDhccpParam::CLEANUP_ACK_WAY);
     7346
     7347        DspinDhccpParam::dspin_set(
    73207348            flit,
    7321             dspin_param::TYPE_CLEANUP_ACK,
    7322             dspin_param::FROM_MC_TYPE);
     7349            DspinDhccpParam::TYPE_CLEANUP_ACK,
     7350            DspinDhccpParam::FROM_MC_TYPE);
    73237351
    73247352        p_dspin_out.write = true;
    … …  
    73337361        if(m_xram_rsp_to_cc_send_inst_fifo.read())
    73347362        {
    7335           multi_inval_type = dspin_param::TYPE_MULTI_INVAL_INST;
     7363          multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
    73367364        }
    73377365        else
    73387366        {
    7339           multi_inval_type = dspin_param::TYPE_MULTI_INVAL_DATA;
     7367          multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
    73407368        }
    73417369
    73427370        uint64_t flit = 0;
    73437371
    7344         dspin_param::dspin_set(
     7372        DspinDhccpParam::dspin_set(
    73457373            flit,
    73467374            m_xram_rsp_to_cc_send_srcid_fifo.read(),
    7347             dspin_param::MULTI_INVAL_DEST);
    7348 
    7349         dspin_param::dspin_set(
     7375            DspinDhccpParam::MULTI_INVAL_DEST);
     7376
     7377        DspinDhccpParam::dspin_set(
    73507378            flit,
    73517379            m_srcid_ini,
    7352             dspin_param::MULTI_INVAL_SRCID);
    7353 
    7354         dspin_param::dspin_set(
     7380            DspinDhccpParam::MULTI_INVAL_SRCID);
     7381
     7382        DspinDhccpParam::dspin_set(
    73557383            flit,
    73567384            r_xram_rsp_to_cc_send_trdid.read(),
    7357             dspin_param::MULTI_INVAL_UPDT_INDEX);
    7358 
    7359         dspin_param::dspin_set(
     7385            DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
     7386
     7387        DspinDhccpParam::dspin_set(
    73607388            flit,
    73617389            multi_inval_type,
    7362             dspin_param::FROM_MC_TYPE);
     7390            DspinDhccpParam::FROM_MC_TYPE);
    73637391
    73647392        p_dspin_out.write = true;
    … …  
    73727400        uint64_t flit = 0;
    73737401
    7374         dspin_param::dspin_set(
     7402        DspinDhccpParam::dspin_set(
    73757403            flit,
    73767404            1ULL,
    7377             dspin_param::FROM_MC_EOP);
    7378 
    7379         dspin_param::dspin_set(
     7405            DspinDhccpParam::FROM_MC_EOP);
     7406
     7407        DspinDhccpParam::dspin_set(
    73807408            flit,
    73817409            r_xram_rsp_to_cc_send_nline.read(),
    7382             dspin_param::MULTI_INVAL_NLINE);
     7410            DspinDhccpParam::MULTI_INVAL_NLINE);
    73837411       
    73847412
    … …  
    73957423        uint64_t flit = 0;
    73967424
    7397         dspin_param::dspin_set(
     7425        DspinDhccpParam::dspin_set(
    73987426            flit,
    73997427            m_broadcast_address,
    7400             dspin_param::BROADCAST_BOX);
    7401 
    7402         dspin_param::dspin_set(
     7428            DspinDhccpParam::BROADCAST_BOX);
     7429
     7430        DspinDhccpParam::dspin_set(
    74037431            flit,
    74047432            m_srcid_ini,
    7405             dspin_param::BROADCAST_SRCID);
    7406 
    7407         dspin_param::dspin_set(
     7433            DspinDhccpParam::BROADCAST_SRCID);
     7434
     7435        DspinDhccpParam::dspin_set(
    74087436            flit,
    74097437            1ULL,
    7410             dspin_param::FROM_MC_BC);
     7438            DspinDhccpParam::FROM_MC_BC);
    74117439
    74127440        p_dspin_out.write = true;
    … …  
    74207448        uint64_t flit = 0;
    74217449
    7422         dspin_param::dspin_set(
     7450        DspinDhccpParam::dspin_set(
    74237451            flit,
    74247452            1ULL,
    7425             dspin_param::FROM_MC_EOP);
    7426 
    7427         dspin_param::dspin_set(
    7428             flit,
    7429             r_xram_rsp_to_cc_send_trdid.read(),
    7430             dspin_param::BROADCAST_UPDT_INDEX);
    7431 
    7432         dspin_param::dspin_set(
     7453            DspinDhccpParam::FROM_MC_EOP);
     7454
     7455        DspinDhccpParam::dspin_set(
    74337456            flit,
    74347457            r_xram_rsp_to_cc_send_nline.read(),
    7435             dspin_param::BROADCAST_NLINE);
     7458            DspinDhccpParam::BROADCAST_NLINE);
    74367459
    74377460        p_dspin_out.write = true;
    … …  
    74457468        uint64_t flit = 0;
    74467469
    7447         dspin_param::dspin_set(
     7470        DspinDhccpParam::dspin_set(
    74487471            flit,
    74497472            1ULL,
    7450             dspin_param::FROM_MC_EOP);
    7451 
    7452         dspin_param::dspin_set(
     7473            DspinDhccpParam::FROM_MC_EOP);
     7474
     7475        DspinDhccpParam::dspin_set(
     7476            flit,
     7477            r_write_to_cc_send_nline.read(),
     7478            DspinDhccpParam::BROADCAST_NLINE);
     7479
     7480        p_dspin_out.write = true;
     7481        p_dspin_out.data  = flit;
     7482
     7483        break;
     7484      }
     7485
     7486    case CC_SEND_CAS_BRDCAST_NLINE:
     7487      {
     7488        uint64_t flit = 0;
     7489
     7490        DspinDhccpParam::dspin_set(
     7491            flit,
     7492            1ULL,
     7493            DspinDhccpParam::FROM_MC_EOP);
     7494
     7495        DspinDhccpParam::dspin_set(
     7496            flit,
     7497            r_cas_to_cc_send_nline.read(),
     7498            DspinDhccpParam::BROADCAST_NLINE);
     7499
     7500        p_dspin_out.write = true;
     7501        p_dspin_out.data  = flit;
     7502
     7503        break;
     7504      }
     7505
     7506    case CC_SEND_WRITE_UPDT_HEADER:
     7507      {
     7508        uint8_t multi_updt_type;
     7509        if(m_write_to_cc_send_inst_fifo.read())
     7510        {
     7511          multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_INST;
     7512        }
     7513        else
     7514        {
     7515          multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_DATA;
     7516        }
     7517
     7518        uint64_t flit = 0;
     7519
     7520        DspinDhccpParam::dspin_set(
     7521            flit,
     7522            m_write_to_cc_send_srcid_fifo.read(),
     7523            DspinDhccpParam::MULTI_UPDT_DEST);
     7524
     7525        DspinDhccpParam::dspin_set(
     7526            flit,
     7527            m_srcid_ini,
     7528            DspinDhccpParam::MULTI_UPDT_SRCID);
     7529
     7530        DspinDhccpParam::dspin_set(
    74537531            flit,
    74547532            r_write_to_cc_send_trdid.read(),
    7455             dspin_param::BROADCAST_UPDT_INDEX);
    7456 
    7457         dspin_param::dspin_set(
     7533            DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
     7534
     7535        DspinDhccpParam::dspin_set(
     7536            flit,
     7537            multi_updt_type,
     7538            DspinDhccpParam::FROM_MC_TYPE);
     7539
     7540        p_dspin_out.write = true;
     7541        p_dspin_out.data  = flit;
     7542
     7543        break;
     7544      }
     7545
     7546    case CC_SEND_WRITE_UPDT_NLINE:
     7547      {
     7548        uint64_t flit = 0;
     7549
     7550        DspinDhccpParam::dspin_set(
     7551            flit,
     7552            r_write_to_cc_send_index.read(),
     7553            DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
     7554
     7555        DspinDhccpParam::dspin_set(
    74587556            flit,
    74597557            r_write_to_cc_send_nline.read(),
    7460             dspin_param::BROADCAST_NLINE);
    7461 
    7462         p_dspin_out.write = true;
    7463         p_dspin_out.data  = flit;
    7464 
    7465         break;
    7466       }
    7467 
    7468     case CC_SEND_CAS_BRDCAST_NLINE:
    7469       {
    7470         uint64_t flit = 0;
    7471 
    7472         dspin_param::dspin_set(
    7473             flit,
    7474             1ULL,
    7475             dspin_param::FROM_MC_EOP);
    7476 
    7477         dspin_param::dspin_set(
    7478             flit,
    7479             r_cas_to_cc_send_trdid.read(),
    7480             dspin_param::BROADCAST_UPDT_INDEX);
    7481 
    7482         dspin_param::dspin_set(
    7483             flit,
    7484             r_cas_to_cc_send_nline.read(),
    7485             dspin_param::BROADCAST_NLINE);
    7486 
    7487         p_dspin_out.write = true;
    7488         p_dspin_out.data  = flit;
    7489 
    7490         break;
    7491       }
    7492 
    7493     case CC_SEND_WRITE_UPDT_HEADER:
    7494       {
    7495         uint8_t multi_updt_type;
    7496         if(m_write_to_cc_send_inst_fifo.read())
    7497         {
    7498           multi_updt_type = dspin_param::TYPE_MULTI_UPDT_INST;
    7499         }
    7500         else
    7501         {
    7502           multi_updt_type = dspin_param::TYPE_MULTI_UPDT_DATA;
    7503         }
    7504 
    7505         uint64_t flit = 0;
    7506 
    7507         dspin_param::dspin_set(
    7508             flit,
    7509             m_write_to_cc_send_srcid_fifo.read(),
    7510             dspin_param::MULTI_UPDT_DEST);
    7511 
    7512         dspin_param::dspin_set(
    7513             flit,
    7514             m_srcid_ini,
    7515             dspin_param::MULTI_UPDT_SRCID);
    7516 
    7517         dspin_param::dspin_set(
    7518             flit,
    7519             r_write_to_cc_send_trdid.read(),
    7520             dspin_param::MULTI_UPDT_UPDT_INDEX);
    7521 
    7522         dspin_param::dspin_set(
    7523             flit,
    7524             multi_updt_type,
    7525             dspin_param::FROM_MC_TYPE);
    7526 
    7527         p_dspin_out.write = true;
    7528         p_dspin_out.data  = flit;
    7529 
    7530         break;
    7531       }
    7532 
    7533     case CC_SEND_WRITE_UPDT_NLINE:
    7534       {
    7535         uint64_t flit = 0;
    7536 
    7537         dspin_param::dspin_set(
    7538             flit,
    7539             r_write_to_cc_send_index.read(),
    7540             dspin_param::MULTI_UPDT_WORD_INDEX);
    7541 
    7542         dspin_param::dspin_set(
    7543             flit,
    7544             r_write_to_cc_send_nline.read(),
    7545             dspin_param::MULTI_UPDT_NLINE);
     7558            DspinDhccpParam::MULTI_UPDT_NLINE);
    75467559
    75477560        p_dspin_out.write = true;
    … …  
    75727585        uint64_t flit = 0;
    75737586
    7574         dspin_param::dspin_set(
     7587        DspinDhccpParam::dspin_set(
    75757588            flit,
    75767589            (uint64_t)multi_updt_eop,
    7577             dspin_param::FROM_MC_EOP);
    7578 
    7579         dspin_param::dspin_set(
     7590            DspinDhccpParam::FROM_MC_EOP);
     7591
     7592        DspinDhccpParam::dspin_set(
    75807593            flit,
    75817594            multi_updt_be,
    7582             dspin_param::MULTI_UPDT_BE);
    7583 
    7584         dspin_param::dspin_set(
     7595            DspinDhccpParam::MULTI_UPDT_BE);
     7596
     7597        DspinDhccpParam::dspin_set(
    75857598            flit,
    75867599            multi_updt_data,
    7587             dspin_param::MULTI_UPDT_DATA);
     7600            DspinDhccpParam::MULTI_UPDT_DATA);
    75887601
    75897602        p_dspin_out.write = true;
    … …  
    75987611        if(m_cas_to_cc_send_inst_fifo.read())
    75997612        {
    7600           multi_updt_type = dspin_param::TYPE_MULTI_UPDT_INST;
     7613          multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_INST;
    76017614        }
    76027615        else
    76037616        {
    7604           multi_updt_type = dspin_param::TYPE_MULTI_UPDT_DATA;
     7617          multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_DATA;
    76057618        }
    76067619
    76077620        uint64_t flit = 0;
    76087621
    7609         dspin_param::dspin_set(
     7622        DspinDhccpParam::dspin_set(
    76107623            flit,
    76117624            m_cas_to_cc_send_srcid_fifo.read(),
    7612             dspin_param::MULTI_UPDT_DEST);
    7613 
    7614         dspin_param::dspin_set(
     7625            DspinDhccpParam::MULTI_UPDT_DEST);
     7626
     7627        DspinDhccpParam::dspin_set(
    76157628            flit,
    76167629            m_srcid_ini,
    7617             dspin_param::MULTI_UPDT_SRCID);
    7618 
    7619         dspin_param::dspin_set(
     7630            DspinDhccpParam::MULTI_UPDT_SRCID);
     7631
     7632        DspinDhccpParam::dspin_set(
    76207633            flit,
    76217634            r_cas_to_cc_send_trdid.read(),
    7622             dspin_param::MULTI_UPDT_UPDT_INDEX);
    7623 
    7624         dspin_param::dspin_set(
     7635            DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
     7636
     7637        DspinDhccpParam::dspin_set(
    76257638            flit,
    76267639            multi_updt_type,
    7627             dspin_param::FROM_MC_TYPE);
     7640            DspinDhccpParam::FROM_MC_TYPE);
    76287641
    76297642        p_dspin_out.write = true;
    … …  
    76377650        uint64_t flit = 0;
    76387651
    7639         dspin_param::dspin_set(
     7652        DspinDhccpParam::dspin_set(
    76407653            flit,
    76417654            r_cas_to_cc_send_index.read(),
    7642             dspin_param::MULTI_UPDT_WORD_INDEX);
    7643 
    7644         dspin_param::dspin_set(
     7655            DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
     7656
     7657        DspinDhccpParam::dspin_set(
    76457658            flit,
    76467659            r_cas_to_cc_send_nline.read(),
    7647             dspin_param::MULTI_UPDT_NLINE);
     7660            DspinDhccpParam::MULTI_UPDT_NLINE);
    76487661
    76497662        p_dspin_out.write = true;
    … …  
    76677680        uint64_t flit = 0;
    76687681
    7669         dspin_param::dspin_set(
     7682        DspinDhccpParam::dspin_set(
    76707683            flit,
    76717684            (uint64_t)multi_updt_eop,
    7672             dspin_param::FROM_MC_EOP);
    7673 
    7674         dspin_param::dspin_set(
     7685            DspinDhccpParam::FROM_MC_EOP);
     7686
     7687        DspinDhccpParam::dspin_set(
    76757688            flit,
    76767689            0xF,
    7677             dspin_param::MULTI_UPDT_BE);
    7678 
    7679         dspin_param::dspin_set(
     7690            DspinDhccpParam::MULTI_UPDT_BE);
     7691
     7692        DspinDhccpParam::dspin_set(
    76807693            flit,
    76817694            r_cas_to_cc_send_wdata.read(),
    7682             dspin_param::MULTI_UPDT_DATA);
     7695            DspinDhccpParam::MULTI_UPDT_DATA);
    76837696
    76847697        p_dspin_out.write = true;
    … …  
    76927705        uint64_t flit = 0;
    76937706
    7694         dspin_param::dspin_set(
     7707        DspinDhccpParam::dspin_set(
    76957708            flit,
    76967709            1ULL,
    7697             dspin_param::FROM_MC_EOP);
    7698 
    7699         dspin_param::dspin_set(
     7710            DspinDhccpParam::FROM_MC_EOP);
     7711
     7712        DspinDhccpParam::dspin_set(
    77007713            flit,
    77017714            0xF,
    7702             dspin_param::MULTI_UPDT_BE);
    7703 
    7704         dspin_param::dspin_set(
     7715            DspinDhccpParam::MULTI_UPDT_BE);
     7716
     7717        DspinDhccpParam::dspin_set(
    77057718            flit,
    77067719            r_cas_to_cc_send_wdata_high.read(),
    7707             dspin_param::MULTI_UPDT_DATA);
     7720            DspinDhccpParam::MULTI_UPDT_DATA);
    77087721
    77097722        p_dspin_out.write = true;
Note: See TracChangeset for help on using the changeset viewer.