Ignore:
Timestamp:
Mar 12, 2013, 3:20:33 PM (11 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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.