Index: anches/RWT/communication/dspin_dhccp_param/caba/metadata/dspin_dhccp_param.sd =================================================================== --- /branches/RWT/communication/dspin_dhccp_param/caba/metadata/dspin_dhccp_param.sd (revision 770) +++ (revision ) @@ -1,4 +1,0 @@ -Module('caba:dspin_dhccp_param', - classname = 'soclib::caba::DspinDhccpParam', - header_files = ['../source/include/dspin_dhccp_param.h',] -) Index: /branches/RWT/communication/dspin_dhccp_param/caba/metadata/dspin_rwt_param.sd =================================================================== --- /branches/RWT/communication/dspin_dhccp_param/caba/metadata/dspin_rwt_param.sd (revision 771) +++ /branches/RWT/communication/dspin_dhccp_param/caba/metadata/dspin_rwt_param.sd (revision 771) @@ -0,0 +1,4 @@ +Module('caba:dspin_rwt_param', + classname = 'soclib::caba::DspinRwtParam', + header_files = ['../source/include/dspin_rwt_param.h',] +) Index: anches/RWT/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h =================================================================== --- /branches/RWT/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h (revision 770) +++ (revision ) @@ -1,425 +1,0 @@ -/* -*- c++ -*- - * File : dspin_dhccp_param.h - * Date : 01/03/2013 - * Copyright : UPMC / LIP6 - * Authors : Cesar Fuguet - * - * SOCLIB_LGPL_HEADER_BEGIN - * - * This file is part of SoCLib, GNU LGPLv2.1. - * - * SoCLib is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; version 2.1 of the License. - * - * SoCLib is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with SoCLib; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - * 02110-1301 USA - * - * SOCLIB_LGPL_HEADER_END - */ - - -#ifndef DSPIN_DHCCP_PARAMS_H -#define DSPIN_DHCCP_PARAMS_H - -#include -#include - -namespace soclib { namespace caba { - -/* - * L1 cache to Memory Cache command packets - * - * CLEANUP - * - * flit 1 - * -------------------------------------------------------------------------------------------------------- - * EOP:0 | DEST | SRCID | NLINE MSB(2 bits)| CONTAINS_DATA | WAY_INDEX(2 bits) | TYPE:0b1X | BC:0 - * | (10 bits) | (14 bits) | | | | | - * -------------------------------------------------------------------------------------------------------- - * | X: 0 DATA | - * | 1 INST | - * flit 2 - * ---------------------------------------------------------------------------------------------- - * EOP:0/1 | NLINE(32 bits) - * ---------------------------------------------------------------------------------------------- - * - * flit N for data - * ---------------------------------------------------------------------------------------------- - * EOP:0/1 | WDATA(32 bits) - * ---------------------------------------------------------------------------------------------- - * - * MULTICAST ACKNOWLEDGEMENT - * - * flit 1 - * ---------------------------------------------------------------------------------------------- - * EOP:1 | DEST(10 bits) | X(15 bits) | UPDT_INDEX(4 bits) | TYPE:0b00 | BC:0 - * ---------------------------------------------------------------------------------------------- - */ - -/* - * M2P command packets - * - * MULTICAST UPDATE - * - * flit 1 - * ---------------------------------------------------------------------------------------------- - * EOP:0 | DEST(14 bits) | X(4 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b0X | BC:0 - * ---------------------------------------------------------------------------------------------- - * | X: 0 DATA | - * | 1 INST | - * flit 2 - * ---------------------------------------------------------------------------------------------- - * EOP:0 | X | WORD_INDEX(4 bits) | NLINE (34 bits) - * ---------------------------------------------------------------------------------------------- - * - * flit 3 - * ---------------------------------------------------------------------------------------------- - * EOP:0 | X(3 bits) | BE(4 bits) | WDATA(32 bits) - * ---------------------------------------------------------------------------------------------- - * - * flit N - * ---------------------------------------------------------------------------------------------- - * EOP:1 | X(3 bits) | BE(4 bits) | WDATA(32 bits) - * ---------------------------------------------------------------------------------------------- - * - * MULTICAST INVALIDATE - * - * flit 1 - * ------------------------------------------------------------------------------------------------------------------ - * EOP:0 | DEST(14 bits) | X (3 bits) | IS_CONFIG (1 bit) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b1X | BC:0 - * ------------------------------------------------------------------------------------------------------------------ - * | X: 0 DATA | - * | 1 INST | - * flit 2 - * ---------------------------------------------------------------------------------------------- - * EOP:1 | X(5 bits) | NLINE (34 bits) - * ---------------------------------------------------------------------------------------------- - * - * BROADCAST INVALIDATE - * - * flit 1 - * | BOUNDING BOX(20 bits) | - * ---------------------------------------------------------------------------------------------- - * EOP:0 | XMIN | XMAX | YMIN | YMAX | MEMC_ID(14 bits) | NETWORK_RESERVED(4 bits) | BC:1 - * ---------------------------------------------------------------------------------------------- - * - * flit 2 - * ---------------------------------------------------------------------------------------------- - * EOP:1 | X(5 bits) | NLINE (34 bits) - * ---------------------------------------------------------------------------------------------- - * - * M2P clack commands - * - * CLEANUP ACKNOWLEDGEMENT - * - * flit 1 - * ---------------------------------------------------------------------------------------------- - * EOP:1 | DEST(14 bits) | X(5 bits) | SET_INDEX(16 bits) | WAY_INDEX(2 bits) | TYPE:0bX | BC:0 - * ---------------------------------------------------------------------------------------------- - * | X: 0 CLACK | - * | DATA | - * | 1 CLACK | - * | INST | - * - */ - -/* - * Utility MACROS - */ -#define GET_FIELD(x,y)\ - case y: return ((x >> y##_SHIFT) & y##_MASK) - -#define SET_FIELD(x,y,z)\ - case z: x |= ((y & z##_MASK) << z##_SHIFT);break - -class DspinDhccpParam -{ - public: - - static const uint8_t m2p_flit_width = 40; - static const uint8_t p2m_flit_width = 33; - static const uint8_t clack_flit_width = 40; - - static const uint8_t UPDT_INDEX_WIDTH = 4; - static const uint8_t NLINE_WIDTH = 34; - static const uint8_t SRCID_WIDTH = 14; - static const uint8_t GLOBALID_WIDTH = 10; - static const uint8_t WORD_INDEX_WIDTH = 4; - static const uint8_t BE_WIDTH = 4; - static const uint8_t DATA_WIDTH = 32; - static const uint8_t SET_INDEX_WIDTH = 6; - static const uint8_t WAY_INDEX_WIDTH = 2; - static const uint8_t BROADCAST_BOX_WIDTH = 20; - static const uint8_t M2P_TYPE_WIDTH = 2; - static const uint8_t P2M_TYPE_WIDTH = 2; - static const uint8_t CLACK_TYPE_WIDTH = 1; - - static const uint8_t P2M_TYPE_SHIFT = 1; - static const uint64_t P2M_TYPE_MASK = ((1ULL< +#include + +namespace soclib { namespace caba { + +/* + * L1 cache to Memory Cache command packets + * + * CLEANUP + * + * flit 1 + * -------------------------------------------------------------------------------------------------------- + * EOP:0 | DEST | SRCID | NLINE MSB(2 bits)| CONTAINS_DATA | WAY_INDEX(2 bits) | TYPE:0b1X | BC:0 + * | (10 bits) | (14 bits) | | | | | + * -------------------------------------------------------------------------------------------------------- + * | X: 0 DATA | + * | 1 INST | + * flit 2 + * ---------------------------------------------------------------------------------------------- + * EOP:0/1 | NLINE(32 bits) + * ---------------------------------------------------------------------------------------------- + * + * flit N for data + * ---------------------------------------------------------------------------------------------- + * EOP:0/1 | WDATA(32 bits) + * ---------------------------------------------------------------------------------------------- + * + * MULTICAST ACKNOWLEDGEMENT + * + * flit 1 + * ---------------------------------------------------------------------------------------------- + * EOP:1 | DEST(10 bits) | X(15 bits) | UPDT_INDEX(4 bits) | TYPE:0b00 | BC:0 + * ---------------------------------------------------------------------------------------------- + */ + +/* + * M2P command packets + * + * MULTICAST UPDATE + * + * flit 1 + * ---------------------------------------------------------------------------------------------- + * EOP:0 | DEST(14 bits) | X(4 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b0X | BC:0 + * ---------------------------------------------------------------------------------------------- + * | X: 0 DATA | + * | 1 INST | + * flit 2 + * ---------------------------------------------------------------------------------------------- + * EOP:0 | X | WORD_INDEX(4 bits) | NLINE (34 bits) + * ---------------------------------------------------------------------------------------------- + * + * flit 3 + * ---------------------------------------------------------------------------------------------- + * EOP:0 | X(3 bits) | BE(4 bits) | WDATA(32 bits) + * ---------------------------------------------------------------------------------------------- + * + * flit N + * ---------------------------------------------------------------------------------------------- + * EOP:1 | X(3 bits) | BE(4 bits) | WDATA(32 bits) + * ---------------------------------------------------------------------------------------------- + * + * MULTICAST INVALIDATE + * + * flit 1 + * ------------------------------------------------------------------------------------------------------------------ + * EOP:0 | DEST(14 bits) | X (3 bits) | IS_CONFIG (1 bit) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b1X | BC:0 + * ------------------------------------------------------------------------------------------------------------------ + * | X: 0 DATA | + * | 1 INST | + * flit 2 + * ---------------------------------------------------------------------------------------------- + * EOP:1 | X(5 bits) | NLINE (34 bits) + * ---------------------------------------------------------------------------------------------- + * + * BROADCAST INVALIDATE + * + * flit 1 + * | BOUNDING BOX(20 bits) | + * ---------------------------------------------------------------------------------------------- + * EOP:0 | XMIN | XMAX | YMIN | YMAX | MEMC_ID(14 bits) | NETWORK_RESERVED(4 bits) | BC:1 + * ---------------------------------------------------------------------------------------------- + * + * flit 2 + * ---------------------------------------------------------------------------------------------- + * EOP:1 | X(5 bits) | NLINE (34 bits) + * ---------------------------------------------------------------------------------------------- + * + * M2P clack commands + * + * CLEANUP ACKNOWLEDGEMENT + * + * flit 1 + * ---------------------------------------------------------------------------------------------- + * EOP:1 | DEST(14 bits) | X(5 bits) | SET_INDEX(16 bits) | WAY_INDEX(2 bits) | TYPE:0bX | BC:0 + * ---------------------------------------------------------------------------------------------- + * | X: 0 CLACK | + * | DATA | + * | 1 CLACK | + * | INST | + * + */ + +/* + * Utility MACROS + */ +#define GET_FIELD(x,y)\ + case y: return ((x >> y##_SHIFT) & y##_MASK) + +#define SET_FIELD(x,y,z)\ + case z: x |= ((y & z##_MASK) << z##_SHIFT);break + +class DspinRwtParam +{ + public: + + static const uint8_t m2p_flit_width = 40; + static const uint8_t p2m_flit_width = 33; + static const uint8_t clack_flit_width = 40; + + static const uint8_t UPDT_INDEX_WIDTH = 4; + static const uint8_t NLINE_WIDTH = 34; + static const uint8_t SRCID_WIDTH = 14; + static const uint8_t GLOBALID_WIDTH = 10; + static const uint8_t WORD_INDEX_WIDTH = 4; + static const uint8_t BE_WIDTH = 4; + static const uint8_t DATA_WIDTH = 32; + static const uint8_t SET_INDEX_WIDTH = 6; + static const uint8_t WAY_INDEX_WIDTH = 2; + static const uint8_t BROADCAST_BOX_WIDTH = 20; + static const uint8_t M2P_TYPE_WIDTH = 2; + static const uint8_t P2M_TYPE_WIDTH = 2; + static const uint8_t CLACK_TYPE_WIDTH = 1; + + static const uint8_t P2M_TYPE_SHIFT = 1; + static const uint64_t P2M_TYPE_MASK = ((1ULL< m_x ; - const soclib::common::AddressMaskingTable m_y ; - const soclib::common::AddressMaskingTable m_z ; + typedef uint32_t data_t; + typedef uint32_t be_t; + + data_t *r_data ; + addr_t *r_tag ; + int *r_state; + bool *r_lru ; + + size_t m_ways; + size_t m_sets; + size_t m_words; + + const soclib::common::AddressMaskingTable m_x ; + const soclib::common::AddressMaskingTable m_y ; + const soclib::common::AddressMaskingTable m_z ; ////////////////////////////////////////////////////////////// @@ -134,10 +134,10 @@ cache_lru(way, set) = true; - for (way2 = 0; way2 < m_ways; way2++ ) + for (way2 = 0; way2 < m_ways; way2++) { if (cache_lru(way2, set) == false) return; } // all lines are new -> they all become old - for (way2 = 0; way2 < m_ways; way2++ ) + for (way2 = 0; way2 < m_ways; way2++) { cache_lru(way2, set) = false; @@ -146,5 +146,5 @@ //////////////////////////////// - inline data_t be2mask( be_t be ) + inline data_t be2mask(be_t be) { data_t mask = 0; @@ -159,8 +159,8 @@ ////////////////////////////////////////// - GenericCache( const std::string &name, - size_t nways, - size_t nsets, - size_t nwords) + GenericCache(const std::string &name, + size_t nways, + size_t nsets, + size_t nwords) : m_ways(nways), m_sets(nsets), @@ -186,5 +186,5 @@ #ifdef GENERIC_CACHE_DEBUG -std::cout << "constructing " << name << std::endl + std::cout << "constructing " << name << std::endl << "- nways = " << nways << std::endl << "- nsets = " << nsets << std::endl @@ -196,8 +196,8 @@ #endif - r_data = new data_t[nways*nsets*nwords]; - r_tag = new addr_t[nways*nsets]; - r_state = new int[nways*nsets]; - r_lru = new bool[nways*nsets]; + r_data = new data_t[nways*nsets*nwords]; + r_tag = new addr_t[nways*nsets]; + r_state = new int[nways*nsets]; + r_lru = new bool[nways*nsets]; } @@ -212,5 +212,5 @@ //////////////////// - inline void reset( ) + inline void reset() { std::memset(r_data, 0, sizeof(*r_data)*m_ways*m_sets*m_words); @@ -230,15 +230,15 @@ // Both data & directory are accessed. ///////////////////////////////////////////////////////////////////// - inline bool read( addr_t ad, - data_t* dt) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) - && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)) ) + inline bool read(addr_t ad, + data_t* dt) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; + + for (size_t way = 0; way < m_ways; way++) + { + if ((tag == cache_tag(way, set)) + && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC)) ) { *dt = cache_data(way, set, word); @@ -256,18 +256,18 @@ // The selected way, set and word index are returned in case of hit. ///////////////////////////////////////////////////////////////////// - inline bool read( addr_t ad, - data_t* dt, - size_t* selway, - size_t* selset, - size_t* selword) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) and - ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC))) + inline bool read(addr_t ad, + data_t* dt, + size_t* selway, + size_t* selset, + size_t* selword) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; + + for (size_t way = 0; way < m_ways; way++) + { + if ((tag == cache_tag(way, set)) and + ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC))) { *selway = way; @@ -292,14 +292,14 @@ // returned in the other arguments. //////////////////////////////////////////////////////////////////// - inline void read( addr_t ad, - data_t* dt, - size_t* selway, - size_t* selset, - size_t* selword, - int* state ) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; + inline void read(addr_t ad, + data_t* dt, + size_t* selway, + size_t* selset, + size_t* selword, + int* state) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; // default return values @@ -310,10 +310,10 @@ *dt = 0; - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( tag == cache_tag(way, set) ) // matching tag - { - - if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC ) + for (size_t way = 0; way < m_ways; way++) + { + if (tag == cache_tag(way, set)) // matching tag + { + + if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) { *state = CACHE_SLOT_STATE_VALID_CC; @@ -324,5 +324,5 @@ cache_set_lru(way, set); } - else if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC ) + else if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) { *state = CACHE_SLOT_STATE_VALID_NCC; @@ -333,5 +333,5 @@ cache_set_lru(way, set); } - else if ( cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI ) + else if (cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI) { *state = CACHE_SLOT_STATE_ZOMBI; @@ -350,18 +350,18 @@ // The selected way, set and word index are returned in case of hit. ///////////////////////////////////////////////////////////////////// - inline bool read_neutral( addr_t ad, - data_t* dt, - size_t* selway, - size_t* selset, - size_t* selword) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) - && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ) ) + inline bool read_neutral(addr_t ad, + data_t* dt, + size_t* selway, + size_t* selset, + size_t* selword) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; + + for (size_t way = 0; way < m_ways; way++) + { + if ((tag == cache_tag(way, set)) + && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) )) { *selway = way; @@ -384,24 +384,24 @@ // This function is used by the cc_vcache to get a 64 bits page table entry. ///////////////////////////////////////////////////////////////////////////// - inline bool read( addr_t ad, - data_t* dt, - data_t* dt_next, - size_t* selway, - size_t* selset, - size_t* selword) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) - &&( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) ) - { - *dt = cache_data(way, set, word); - if ( word+1 < m_words) - { - *dt_next = cache_data(way, set, word+1); + inline bool read( addr_t ad, + data_t* dt, + data_t* dt_next, + size_t* selway, + size_t* selset, + size_t* selword) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; + + for (size_t way = 0; way < m_ways; way++) + { + if ((tag == cache_tag(way, set)) + &&( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC))) + { + *dt = cache_data(way, set, word); + if (word + 1 < m_words) + { + *dt_next = cache_data(way, set, word + 1); } *selway = way; @@ -425,15 +425,15 @@ // returned in the other arguments. //////////////////////////////////////////////////////////////////// - inline void read( addr_t ad, - data_t* dt, - data_t* dt_next, - size_t* selway, - size_t* selset, - size_t* selword, - int* state ) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; + inline void read(addr_t ad, + data_t* dt, + data_t* dt_next, + size_t* selway, + size_t* selset, + size_t* selword, + int* state) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; // default return values @@ -444,10 +444,10 @@ *dt = 0; - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( tag == cache_tag(way, set) ) // matching tag - { - - if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC ) + for (size_t way = 0; way < m_ways; way++) + { + if (tag == cache_tag(way, set)) // matching tag + { + + if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) { *state = CACHE_SLOT_STATE_VALID_CC; @@ -456,5 +456,5 @@ *selword = word; *dt = cache_data(way, set, word); - if ( word+1 < m_words) + if (word + 1 < m_words) { *dt_next = cache_data(way, set, word+1); @@ -463,5 +463,5 @@ } - else if ( cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC ) + else if (cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) { *state = CACHE_SLOT_STATE_VALID_NCC; @@ -470,12 +470,12 @@ *selword = word; *dt = cache_data(way, set, word); - if ( word+1 < m_words) + if (word + 1 < m_words) { - *dt_next = cache_data(way, set, word+1); + *dt_next = cache_data(way, set, word + 1); } cache_set_lru(way, set); } - else if ( cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI ) + else if (cache_state(way, set) == CACHE_SLOT_STATE_ZOMBI) { *state = CACHE_SLOT_STATE_ZOMBI; @@ -496,17 +496,17 @@ // while we write in the data part with a different address in the same cycle. /////////////////////////////////////////////////////////////////////////////// - inline bool hit( addr_t ad, - size_t* selway, - size_t* selset, - size_t* selword) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) - && ( (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or(cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC) ) ) + inline bool hit(addr_t ad, + size_t* selway, + size_t* selset, + size_t* selword) + { + const addr_t tag = m_z[ad]; + const size_t set = m_y[ad]; + const size_t word = m_x[ad]; + + for (size_t way = 0; way < m_ways; way++) + { + if ((tag == cache_tag(way, set)) + && ((cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC)or(cache_state(way, set) == CACHE_SLOT_STATE_VALID_NCC))) { *selway = way; @@ -531,17 +531,17 @@ // while we write in the data part with a different address in the same cycle. /////////////////////////////////////////////////////////////////////////////// - inline void read_dir( addr_t ad, - int* state, - size_t* way, - size_t* set, - size_t* word) - { - const addr_t ad_tag = m_z[ad]; - const size_t ad_set = m_y[ad]; - const size_t ad_word = m_x[ad]; - for ( size_t _way = 0; _way < m_ways; _way++ ) - { - if ( (ad_tag == cache_tag(_way, ad_set) ) and - (cache_state(_way, ad_set) != CACHE_SLOT_STATE_EMPTY) ) + inline void read_dir(addr_t ad, + int* state, + size_t* way, + size_t* set, + size_t* word) + { + const addr_t ad_tag = m_z[ad]; + const size_t ad_set = m_y[ad]; + const size_t ad_word = m_x[ad]; + for (size_t _way = 0; _way < m_ways; _way++) + { + if ((ad_tag == cache_tag(_way, ad_set)) and + (cache_state(_way, ad_set) != CACHE_SLOT_STATE_EMPTY)) { *state = cache_state(_way, ad_set); @@ -562,8 +562,8 @@ // Returns the access status and the tag value in the state and tag argument. /////////////////////////////////////////////////////////////////////////////// - inline void read_dir( size_t way, - size_t set, - addr_t* tag, - int* state ) + inline void read_dir(size_t way, + size_t set, + addr_t* tag, + int* state) { *state = cache_state(way, set); @@ -581,8 +581,8 @@ // It does not use the directory and cannot miss. ////////////////////////////////////////////////////////////////// - inline void write(size_t way, - size_t set, - size_t word, - data_t data) + inline void write(size_t way, + size_t set, + size_t word, + data_t data) { cache_data(way, set, word) = data; @@ -594,9 +594,9 @@ // It does not use the directory and cannot miss. //////////////////////////////////////////////////////////////////////////// - inline void write(size_t way, - size_t set, - size_t word, - data_t data, - be_t be) + inline void write(size_t way, + size_t set, + size_t word, + data_t data, + be_t be) { data_t mask = be2mask(be); @@ -610,9 +610,9 @@ // It returns true if the line was valid, and returns the line index. ////////////////////////////////////////////////////////////////////////// - inline bool inval(size_t way, - size_t set, - addr_t* nline) - { - if( (cache_state(way,set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way,set) == CACHE_SLOT_STATE_VALID_NCC)) + inline bool inval(size_t way, + size_t set, + addr_t* nline) + { + if ((cache_state(way,set) == CACHE_SLOT_STATE_VALID_CC) or (cache_state(way,set) == CACHE_SLOT_STATE_VALID_NCC)) { cache_state(way,set) = CACHE_SLOT_STATE_EMPTY; @@ -631,11 +631,11 @@ // and a Boolean indicating that a cleanup is requested. ////////////////////////////////////////////////////////////////////////////////// - inline bool victim_select(addr_t ad, - addr_t* victim, - size_t* way, - size_t* set) - { - bool found = false; - bool cleanup = false; + inline bool victim_select(addr_t ad, + addr_t* victim, + size_t* way, + size_t* set) + { + bool found = false; + bool cleanup = false; *set = m_y[ad]; @@ -643,7 +643,7 @@ // Search first empty slot - for ( size_t _way = 0 ; _way < m_ways && !found ; _way++ ) - { - if( ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_CC ) and ( cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_NCC )) // empty + for (size_t _way = 0 ; _way < m_ways && !found ; _way++) + { + if ((cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_CC) and (cache_state(_way, *set) != CACHE_SLOT_STATE_VALID_NCC )) // empty { found = true; @@ -654,9 +654,9 @@ // If no empty slot, search first old slot (lru == false) - if ( !found ) + if (!found) { - for ( size_t _way = 0 ; _way < m_ways && !found ; _way++ ) - { - if ( not cache_lru(_way, *set) ) + for (size_t _way = 0 ; _way < m_ways && !found ; _way++) + { + if (not cache_lru(_way, *set)) { found = true; @@ -668,5 +668,5 @@ assert(found && "all ways can't be new at the same time"); - *victim = (addr_t)((cache_tag(*way,*set) * m_sets) + *set); + *victim = (addr_t) ((cache_tag(*way,*set) * m_sets) + *set); return cleanup; } @@ -681,10 +681,10 @@ // and two Boolean indicating success and a required cleanup. ////////////////////////////////////////////////////////////////////////////////// - inline void read_select(addr_t ad, - addr_t* victim, - size_t* way, - size_t* set, - bool* found, - bool* cleanup ) + inline void read_select(addr_t ad, + addr_t* victim, + size_t* way, + size_t* set, + bool* found, + bool* cleanup) { size_t _set = m_y[ad]; @@ -693,7 +693,7 @@ // Search first empty slot - for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ ) - { - if ( cache_state(_way, _set) == CACHE_SLOT_STATE_EMPTY ) + for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++) + { + if (cache_state(_way, _set) == CACHE_SLOT_STATE_EMPTY) { *found = true; @@ -704,24 +704,10 @@ } } - ////////////////////////////////////////////////////////////// - /*for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ ) - { - if ( not cache_lru(_way, _set) and - (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) and - (cache_state(_way, _set) == CACHE_SLOT_STATE_VALID_NCC) ) - { - *found = true; - *cleanup = true; - *way = _way; - *set = m_y[ad]; - *victim = (addr_t)((cache_tag(*way,_set) * m_sets) + _set); - return; - } - }*/ + // Search first not zombi old slot - for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ ) - { - if ( not cache_lru(_way, _set) and - (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) ) + for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++) + { + if (not cache_lru(_way, _set) and + (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI)) { *found = true; @@ -734,7 +720,7 @@ } // Search first not zombi slot - for ( size_t _way = 0 ; _way < m_ways && !(*found) ; _way++ ) - { - if ( cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) + for (size_t _way = 0 ; _way < m_ways && !(*found) ; _way++) + { + if (cache_state(_way, _set) != CACHE_SLOT_STATE_ZOMBI) { *found = true; @@ -756,7 +742,7 @@ // identified by the way & set. ////////////////////////////////////////////////////////////////// - inline void victim_update_tag( addr_t ad, - size_t way, - size_t set ) + inline void victim_update_tag(addr_t ad, + size_t way, + size_t set) { addr_t tag = m_z[ad]; @@ -771,10 +757,10 @@ // identified by the way & set, when using the ZOMBI state. ////////////////////////////////////////////////////////////////// - inline void write_dir( addr_t ad, - size_t way, - size_t set, - int state) - { - addr_t tag = m_z[ad]; + inline void write_dir(addr_t ad, + size_t way, + size_t set, + int state) + { + addr_t tag = m_z[ad]; assert( ( (state == CACHE_SLOT_STATE_VALID_CC) or @@ -793,5 +779,5 @@ cache_state(way, set) = state; - if ( (state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC) ) cache_set_lru(way, set); + if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC)) cache_set_lru(way, set); } @@ -801,7 +787,7 @@ // It does not affect the tag ////////////////////////////////////////////////////////////////// - inline void write_dir( size_t way, - size_t set, - int state) + inline void write_dir(size_t way, + size_t set, + int state) { assert( ( (state == CACHE_SLOT_STATE_VALID_CC) or @@ -827,8 +813,8 @@ // Both DATA and DIRECTORY are written /////////////////////////////////////////////////////////////////// - inline void update(addr_t ad, - size_t way, - size_t set, - data_t* buf) + inline void update(addr_t ad, + size_t way, + size_t set, + data_t* buf) { addr_t tag = m_z[ad]; @@ -837,5 +823,5 @@ cache_state(way, set) = CACHE_SLOT_STATE_VALID_CC; cache_set_lru(way, set); - for ( size_t word = 0 ; word < m_words ; word++ ) + for (size_t word = 0 ; word < m_words ; word++) { cache_data(way, set, word) = buf[word] ; @@ -846,7 +832,7 @@ void fileTrace(FILE* file) { - for( size_t nway = 0 ; nway < m_ways ; nway++) - { - for( size_t nset = 0 ; nset < m_sets ; nset++) + for (size_t nway = 0 ; nway < m_ways ; nway++) + { + for (size_t nset = 0 ; nset < m_sets ; nset++) { fprintf(file, "%d / ", (int)cache_state(nway, nset)); @@ -854,9 +840,9 @@ fprintf(file, "set %d / ", (int)nset); fprintf(file, "@ = %08zX / ", - ((cache_tag(nway, nset)*m_sets+nset)*m_words*4)); - for( size_t nword = m_words ; nword > 0 ; nword--) - { - unsigned int data = cache_data(nway, nset, nword-1); - fprintf(file, "%08X ", data ); + ((cache_tag(nway, nset) * m_sets + nset) * m_words * 4)); + for (size_t nword = m_words ; nword > 0 ; nword--) + { + unsigned int data = cache_data(nway, nset, nword - 1); + fprintf(file, "%08X ", data); } fprintf(file, "\n"); @@ -868,7 +854,7 @@ inline void printTrace() { - for ( size_t way = 0; way < m_ways ; way++ ) - { - for ( size_t set = 0 ; set < m_sets ; set++ ) + for (size_t way = 0; way < m_ways ; way++) + { + for (size_t set = 0 ; set < m_sets ; set++) { addr_t addr = (((addr_t)cache_tag(way,set))*m_words*m_sets+m_words*set)*4; @@ -878,5 +864,5 @@ << std::hex << " | @ " << addr; - for ( size_t word = 0 ; word < m_words ; word++ ) + for (size_t word = 0 ; word < m_words ; word++) { std::cout << " | " << cache_data(way,set,word) ; @@ -886,180 +872,5 @@ } } - - /////////////////////////////////////////////////////////////////////////// - // This function is deprecated as it is difficult to implement in 1 cycle. - /////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool inval(addr_t ad) - { - bool hit = false; - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - - for ( size_t way = 0 ; way < m_ways && !hit ; way++ ) - { - if ( (tag == cache_tag(way, set)) and - (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) - { - hit = true; - cache_state(way, set) = CACHE_SLOT_STATE_EMPTY; - cache_lru(way, set) = false; - } - } - return hit; - } - - //////////////////////////////////////////////////////////////////////////////// - // This function is deprecated as it is difficult to implement in 1 cycle. - //////////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool inval( addr_t ad, - size_t* selway, - size_t* selset ) - { - bool hit = false; - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - - for ( size_t way = 0 ; way < m_ways && !hit ; way++ ) - { - if ( (tag == cache_tag(way, set)) and - (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) - { - hit = true; - cache_state(way, set) = CACHE_SLOT_STATE_EMPTY; - cache_lru(way, set) = false; - *selway = way; - *selset = set; - } - } - return hit; - } - - //////////////////////////////////////////////////////////////////////////////// - // This function is deprecated as the directory must be a dual port RAM... - //////////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool update( addr_t ad, - data_t* buf, - addr_t* victim ) - { - size_t set, way; - bool cleanup = victim_select(ad, victim, &way, &set); - victim_update_tag (ad, way, set); - - for ( size_t word = 0 ; word < m_words ; word++ ) { - cache_data(way, set, word) = buf[word] ; - } - - return cleanup; - } - - //////////////////////////////////////////////////////////////////////////// - // this function is deprecated, as it is difficult to implement in 1 cycle. - //////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool write(addr_t ad, - data_t dt) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) and - (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) - { - cache_data(way, set, word) = dt; - cache_set_lru(way, set); - return true; - } - } - return false; - } - - //////////////////////////////////////////////////////////////////////////// - // this function is deprecated, as it is difficult to implement in 1 cycle. - //////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool write(addr_t ad, - data_t dt, - be_t be) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) and - (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) - { - data_t mask = be2mask(be); - data_t prev = cache_data(way, set, word); - cache_data(way, set, word) = (mask & dt) | (~mask & prev); - cache_set_lru(way, set); - return true; - } - } - return false; - } - - ///////////////////////////////////////////////////////////////////////////// - // this function is deprecated, as it is difficult to implement in 1 cycle. - ///////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool write(addr_t ad, - data_t dt, - size_t* nway) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) and - (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) - { - cache_data(way, set, word) = dt; - cache_set_lru(way, set); - *nway = way; - return true; - } - } - return false; - } - - ///////////////////////////////////////////////////////////////////////////// - // this function is deprecated, as it is difficult to implement in 1 cycle. - ///////////////////////////////////////////////////////////////////////////// - __attribute__((deprecated)) - inline bool write(addr_t ad, - data_t dt, - size_t* nway, - be_t be) - { - const addr_t tag = m_z[ad]; - const size_t set = m_y[ad]; - const size_t word = m_x[ad]; - - for ( size_t way = 0; way < m_ways; way++ ) - { - if ( (tag == cache_tag(way, set)) and - (cache_state(way, set) == CACHE_SLOT_STATE_VALID_CC) ) - { - data_t mask = be2mask(be); - data_t prev = cache_data(way, set, word); - cache_data(way, set, word) = (mask & dt) | (~mask & prev); - cache_set_lru(way, set); - *nway = way; - return true; - } - } - return false; - } - + }; Index: /branches/RWT/lib/generic_cache_tsar/metadata/generic_cache.sd =================================================================== --- /branches/RWT/lib/generic_cache_tsar/metadata/generic_cache.sd (revision 770) +++ /branches/RWT/lib/generic_cache_tsar/metadata/generic_cache.sd (revision 771) @@ -4,12 +4,14 @@ __version__ = "$Revision: 917 $" -Module('caba:generic_cache_tsar', - classname = 'soclib::GenericCache', - header_files = ['../include/generic_cache.h',], - tmpl_parameters = [ - parameter.Type('addr_t'), - ], - uses = [Uses('common:mapping_table'), - Uses('common:address_masking_table', - data_t = parameter.Reference('addr_t')),], +Module('caba:generic_cache_tsar_rwt', + classname = 'soclib::GenericCache', + header_files = ['../include/generic_cache.h',], + tmpl_parameters = [ + parameter.Type('addr_t'), + ], + uses = [ + Uses('common:mapping_table'), + Uses('common:address_masking_table', + data_t = parameter.Reference('addr_t')), + ], ) Index: /branches/RWT/modules/vci_cc_vcache_wrapper/caba/metadata/vci_cc_vcache_wrapper.sd =================================================================== --- /branches/RWT/modules/vci_cc_vcache_wrapper/caba/metadata/vci_cc_vcache_wrapper.sd (revision 770) +++ /branches/RWT/modules/vci_cc_vcache_wrapper/caba/metadata/vci_cc_vcache_wrapper.sd (revision 771) @@ -3,24 +3,24 @@ Module('caba:vci_cc_vcache_wrapper', - classname = 'soclib::caba::VciCcVCacheWrapper', + classname = 'soclib::caba::VciCcVCacheWrapper', - tmpl_parameters = [ + tmpl_parameters = [ parameter.Module('vci_param', default = 'caba:vci_param'), parameter.Int('dspin_in_width'), parameter.Int('dspin_out_width'), - parameter.Module('iss_t') + parameter.Module('iss_t') ], - header_files = [ '../source/include/vci_cc_vcache_wrapper.h' ], + header_files = [ '../source/include/vci_cc_vcache_wrapper.h' ], - implementation_files = [ '../source/src/vci_cc_vcache_wrapper.cpp' ], + implementation_files = [ '../source/src/vci_cc_vcache_wrapper.cpp' ], - uses = [ + uses = [ Uses('caba:base_module'), Uses('common:mapping_table'), - Uses('common:iss2'), - Uses('caba:multi_write_buffer'), - Uses('caba:generic_fifo'), - Uses('caba:generic_cache_tsar', + Uses('common:iss2'), + Uses('caba:multi_write_buffer'), + Uses('caba:generic_fifo'), + Uses('caba:generic_cache_tsar_rwt', addr_t = parameter.StringExt('sc_dt::sc_uint<%d> ', parameter.Reference('addr_size'))), @@ -32,8 +32,8 @@ parameter.Reference('addr_size')) ), - Uses('caba:dspin_dhccp_param'), + Uses('caba:dspin_rwt_param'), ], - ports = [ + ports = [ Port('caba:vci_initiator', 'p_vci'), Port('caba:dspin_input', 'p_dspin_m2p', @@ -43,29 +43,29 @@ Port('caba:dspin_input', 'p_dspin_clack', dspin_data_size = parameter.Reference('dspin_in_width')), - Port('caba:bit_in','p_irq', parameter.Constant('n_irq')), - Port('caba:bit_in', 'p_resetn', auto = 'resetn'), - Port('caba:clock_in', 'p_clk', auto = 'clock') + Port('caba:bit_in','p_irq', parameter.Constant('n_irq')), + Port('caba:bit_in', 'p_resetn', auto = 'resetn'), + Port('caba:clock_in', 'p_clk', auto = 'clock') ], - instance_parameters = [ + instance_parameters = [ parameter.Int('proc_id'), - parameter.Module('mt', 'common:mapping_table'), - parameter.Module('mc', 'common:mapping_table'), - parameter.IntTab('initiator_rw_index'), - parameter.IntTab('initiator_c_index'), - parameter.IntTab('target_index'), - parameter.Int('itlb_ways'), - parameter.Int('itlb_sets'), - parameter.Int('dtlb_ways'), - parameter.Int('dtlb_sets'), - parameter.Int('icache_ways'), - parameter.Int('icache_sets'), - parameter.Int('icache_words'), - parameter.Int('dcache_ways'), - parameter.Int('dcache_sets'), - parameter.Int('dcache_words'), - parameter.Int('wbuf_nlines'), - parameter.Int('wbuf_nwords'), - parameter.Int('max_frozen_cycles') + parameter.Module('mt', 'common:mapping_table'), + parameter.Module('mc', 'common:mapping_table'), + parameter.IntTab('initiator_rw_index'), + parameter.IntTab('initiator_c_index'), + parameter.IntTab('target_index'), + parameter.Int('itlb_ways'), + parameter.Int('itlb_sets'), + parameter.Int('dtlb_ways'), + parameter.Int('dtlb_sets'), + parameter.Int('icache_ways'), + parameter.Int('icache_sets'), + parameter.Int('icache_words'), + parameter.Int('dcache_ways'), + parameter.Int('dcache_sets'), + parameter.Int('dcache_words'), + parameter.Int('wbuf_nlines'), + parameter.Int('wbuf_nwords'), + parameter.Int('max_frozen_cycles') ], ) Index: /branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h =================================================================== --- /branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h (revision 770) +++ /branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h (revision 771) @@ -35,4 +35,5 @@ #include #include + #include "caba_base_module.h" #include "multi_write_buffer.h" @@ -42,5 +43,5 @@ #include "vci_initiator.h" #include "dspin_interface.h" -#include "dspin_dhccp_param.h" +#include "dspin_rwt_param.h" #include "mapping_table.h" #include "static_assert.h" Index: /branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp =================================================================== --- /branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp (revision 770) +++ /branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp (revision 771) @@ -4289,6 +4289,6 @@ uint32_t rdata; - size_t way; - size_t set; + size_t way = 0; // To avoid gcc warning + size_t set = 0; // To avoid gcc warning size_t word; r_dcache.read_neutral(r_dcache_xtn_data_addr.read(), @@ -5379,6 +5379,6 @@ uint32_t rdata; - size_t way; - size_t set; + size_t way = 0; // to avoid gcc warning + size_t set = 0; // to avoid gcc warning size_t word; r_dcache.read_neutral(r_dcache_cc_inval_addr.read(), @@ -5399,7 +5399,7 @@ r_dcache_cc_inval_data_cpt = 0; r_dcache_fsm = r_dcache_fsm_cc_save.read(); - r_dcache.write_dir( way, - set, - CACHE_SLOT_STATE_ZOMBI ); + r_dcache.write_dir(way, + set, + CACHE_SLOT_STATE_ZOMBI ); } } @@ -6207,22 +6207,22 @@ uint64_t receive_data = p_dspin_m2p.data.read(); // initialize coherence packet type - uint64_t receive_type = DspinDhccpParam::dspin_get(receive_data, - DspinDhccpParam::M2P_TYPE); + uint64_t receive_type = DspinRwtParam::dspin_get(receive_data, + DspinRwtParam::M2P_TYPE); // test for a broadcast - if (DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::M2P_BC)) + if (DspinRwtParam::dspin_get(receive_data,DspinRwtParam::M2P_BC)) { r_cc_receive_fsm = CC_RECEIVE_BRDCAST_HEADER; } // test for a multi updt - else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA) + else if (receive_type == DspinRwtParam::TYPE_MULTI_UPDT_DATA) { r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_HEADER; } - else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_INST) + else if (receive_type == DspinRwtParam::TYPE_MULTI_UPDT_INST) { r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_HEADER; } // test for a multi inval - else if (receive_type == DspinDhccpParam::TYPE_MULTI_INVAL_DATA) + else if (receive_type == DspinRwtParam::TYPE_MULTI_INVAL_DATA) { r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_HEADER; @@ -6257,11 +6257,11 @@ // request dcache to handle the BROADCAST r_cc_receive_dcache_req = true; - r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data, - DspinDhccpParam::BROADCAST_NLINE); + r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data, + DspinRwtParam::BROADCAST_NLINE); r_cc_receive_dcache_type = CC_TYPE_INVAL; // request icache to handle the BROADCAST r_cc_receive_icache_req = true; - r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data, - DspinDhccpParam::BROADCAST_NLINE); + r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data, + DspinRwtParam::BROADCAST_NLINE); r_cc_receive_icache_type = CC_TYPE_INVAL; // get back to idle state @@ -6279,6 +6279,6 @@ // sample updt tab index in the HEADER, then skip to second flit r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_NLINE; - r_cc_receive_dcache_inval_is_config = DspinDhccpParam::dspin_get(receive_data, - DspinDhccpParam::MULTI_INVAL_IS_CONFIG); + r_cc_receive_dcache_inval_is_config = DspinRwtParam::dspin_get(receive_data, + DspinRwtParam::MULTI_INVAL_IS_CONFIG); break; } @@ -6301,5 +6301,5 @@ // request dcache to handle the INVAL r_cc_receive_dcache_req = true; - r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE); + r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_INVAL_NLINE); r_cc_receive_dcache_type = CC_TYPE_INVAL; // get back to idle state @@ -6320,5 +6320,5 @@ // request icache to handle the INVAL r_cc_receive_icache_req = true; - r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE); + r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_INVAL_NLINE); r_cc_receive_icache_type = CC_TYPE_INVAL; // get back to idle state @@ -6337,5 +6337,5 @@ if (not r_cc_receive_dcache_req.read()) { - r_cc_receive_dcache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX); + r_cc_receive_dcache_updt_tab_idx = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_UPDT_INDEX); r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_NLINE; break; @@ -6352,5 +6352,5 @@ if (not r_cc_receive_icache_req.read()) { - r_cc_receive_icache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX); + r_cc_receive_icache_updt_tab_idx = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_UPDT_INDEX); r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_NLINE; break; @@ -6370,6 +6370,6 @@ { r_cc_receive_dcache_req = true; - r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE); - r_cc_receive_word_idx = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX); + r_cc_receive_dcache_nline = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_NLINE); + r_cc_receive_word_idx = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_WORD_INDEX); r_cc_receive_dcache_type = CC_TYPE_UPDT; // get back to idle state @@ -6390,6 +6390,6 @@ { r_cc_receive_icache_req = true; - r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE); - r_cc_receive_word_idx = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX); + r_cc_receive_icache_nline = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_NLINE); + r_cc_receive_word_idx = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_WORD_INDEX); r_cc_receive_icache_type = CC_TYPE_UPDT; // get back to idle state @@ -6407,6 +6407,6 @@ uint64_t receive_data = p_dspin_m2p.data.read(); bool receive_eop = p_dspin_m2p.eop.read(); - cc_receive_updt_fifo_be = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE); - cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA); + cc_receive_updt_fifo_be = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_BE); + cc_receive_updt_fifo_data = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_DATA); cc_receive_updt_fifo_eop = receive_eop; cc_receive_updt_fifo_put = true; @@ -6423,6 +6423,6 @@ uint64_t receive_data = p_dspin_m2p.data.read(); bool receive_eop = p_dspin_m2p.eop.read(); - cc_receive_updt_fifo_be = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE); - cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA); + cc_receive_updt_fifo_be = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_BE); + cc_receive_updt_fifo_data = DspinRwtParam::dspin_get(receive_data,DspinRwtParam::MULTI_UPDT_DATA); cc_receive_updt_fifo_eop = receive_eop; cc_receive_updt_fifo_put = true; @@ -6436,16 +6436,16 @@ ///////////////// DSPIN CLACK interface /////////////// - uint64_t clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(), - DspinDhccpParam::CLACK_TYPE); - - size_t clack_way = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(), - DspinDhccpParam::CLACK_WAY); - - size_t clack_set = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(), - DspinDhccpParam::CLACK_SET); + uint64_t clack_type = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(), + DspinRwtParam::CLACK_TYPE); + + size_t clack_way = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(), + DspinRwtParam::CLACK_WAY); + + size_t clack_set = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(), + DspinRwtParam::CLACK_SET); bool dspin_clack_get = false; - bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA); - bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST); + bool dcache_clack_request = (clack_type == DspinRwtParam::TYPE_CLACK_DATA); + bool icache_clack_request = (clack_type == DspinRwtParam::TYPE_CLACK_INST); if (r_dspin_clack_req.read()) @@ -6701,10 +6701,10 @@ { // initialize dspin send data - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, m_cc_global_id, - DspinDhccpParam::CLEANUP_SRCID); - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_SRCID); + DspinRwtParam::dspin_set(dspin_send_data, 0, - DspinDhccpParam::P2M_BC); + DspinRwtParam::P2M_BC); if(r_cc_send_last_client.read() == 0) // dcache active request @@ -6712,24 +6712,24 @@ uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read() >> (m_nline_width - m_x_width - m_y_width) - << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width); - DspinDhccpParam::dspin_set(dspin_send_data, + << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width); + DspinRwtParam::dspin_set(dspin_send_data, dest, - DspinDhccpParam::CLEANUP_DEST); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_DEST); + + DspinRwtParam::dspin_set(dspin_send_data, (r_dcache_cc_send_nline.read() & 0x300000000ULL)>>32, - DspinDhccpParam::CLEANUP_NLINE_MSB); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_NLINE_MSB); + + DspinRwtParam::dspin_set(dspin_send_data, r_dcache_cc_send_way.read(), - DspinDhccpParam::CLEANUP_WAY_INDEX); - - DspinDhccpParam::dspin_set(dspin_send_data, - DspinDhccpParam::TYPE_CLEANUP_DATA, - DspinDhccpParam::P2M_TYPE); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_WAY_INDEX); + + DspinRwtParam::dspin_set(dspin_send_data, + DspinRwtParam::TYPE_CLEANUP_DATA, + DspinRwtParam::P2M_TYPE); + + DspinRwtParam::dspin_set(dspin_send_data, (r_dcache_cc_cleanup_line_ncc.read() and (r_cc_send_last_client.read() == 0)), - DspinDhccpParam::CLEANUP_NCC); + DspinRwtParam::CLEANUP_NCC); } else // icache active request @@ -6737,25 +6737,25 @@ uint64_t dest = (uint64_t) r_icache_cc_send_nline.read() >> (m_nline_width - m_x_width - m_y_width) - << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width); - - DspinDhccpParam::dspin_set(dspin_send_data, + << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width); + + DspinRwtParam::dspin_set(dspin_send_data, dest, - DspinDhccpParam::CLEANUP_DEST); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_DEST); + + DspinRwtParam::dspin_set(dspin_send_data, (r_icache_cc_send_nline.read() & 0x300000000ULL)>>32, - DspinDhccpParam::CLEANUP_NLINE_MSB); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_NLINE_MSB); + + DspinRwtParam::dspin_set(dspin_send_data, r_icache_cc_send_way.read(), - DspinDhccpParam::CLEANUP_WAY_INDEX); - - DspinDhccpParam::dspin_set(dspin_send_data, - DspinDhccpParam::TYPE_CLEANUP_INST, - DspinDhccpParam::P2M_TYPE); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::CLEANUP_WAY_INDEX); + + DspinRwtParam::dspin_set(dspin_send_data, + DspinRwtParam::TYPE_CLEANUP_INST, + DspinRwtParam::P2M_TYPE); + + DspinRwtParam::dspin_set(dspin_send_data, 0, - DspinDhccpParam::CLEANUP_NCC); + DspinRwtParam::CLEANUP_NCC); @@ -6773,13 +6773,13 @@ if(r_cc_send_last_client.read() == 0) // dcache active request { - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, r_dcache_cc_send_nline.read() & 0xFFFFFFFFULL, - DspinDhccpParam::CLEANUP_NLINE_LSB); + DspinRwtParam::CLEANUP_NLINE_LSB); } else // icache active request { - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, r_icache_cc_send_nline.read() & 0xFFFFFFFFULL, - DspinDhccpParam::CLEANUP_NLINE_LSB); + DspinRwtParam::CLEANUP_NLINE_LSB); } // send flit @@ -6793,7 +6793,7 @@ { - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, r_cc_send_data_fifo.read(), - DspinDhccpParam::CLEANUP_DATA_UPDT); + DspinRwtParam::CLEANUP_DATA_UPDT); p_dspin_p2m.data = dspin_send_data; @@ -6806,10 +6806,10 @@ { // initialize dspin send data - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, 0, - DspinDhccpParam::P2M_BC); - DspinDhccpParam::dspin_set(dspin_send_data, - DspinDhccpParam::TYPE_MULTI_ACK, - DspinDhccpParam::P2M_TYPE); + DspinRwtParam::P2M_BC); + DspinRwtParam::dspin_set(dspin_send_data, + DspinRwtParam::TYPE_MULTI_ACK, + DspinRwtParam::P2M_TYPE); if(r_cc_send_last_client.read() == 0) // dcache active request @@ -6817,13 +6817,13 @@ uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read() >> (m_nline_width - m_x_width - m_y_width) - << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width); + << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width); - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, dest, - DspinDhccpParam::MULTI_ACK_DEST); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::MULTI_ACK_DEST); + + DspinRwtParam::dspin_set(dspin_send_data, r_dcache_cc_send_updt_tab_idx.read(), - DspinDhccpParam::MULTI_ACK_UPDT_INDEX); + DspinRwtParam::MULTI_ACK_UPDT_INDEX); } else // icache active request @@ -6831,14 +6831,14 @@ uint64_t dest = (uint64_t) r_icache_cc_send_nline.read() >> (m_nline_width - m_x_width - m_y_width) - << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width); + << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width); - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::dspin_set(dspin_send_data, dest, - DspinDhccpParam::MULTI_ACK_DEST); - - DspinDhccpParam::dspin_set(dspin_send_data, + DspinRwtParam::MULTI_ACK_DEST); + + DspinRwtParam::dspin_set(dspin_send_data, r_icache_cc_send_updt_tab_idx.read(), - DspinDhccpParam::MULTI_ACK_UPDT_INDEX); + DspinRwtParam::MULTI_ACK_UPDT_INDEX); } // send flit @@ -6938,10 +6938,10 @@ - int clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(), - DspinDhccpParam::CLACK_TYPE); + int clack_type = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(), + DspinRwtParam::CLACK_TYPE); bool dspin_clack_get = false; - bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA); - bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST); + bool dcache_clack_request = (clack_type == DspinRwtParam::TYPE_CLACK_DATA); + bool icache_clack_request = (clack_type == DspinRwtParam::TYPE_CLACK_INST); if (r_dspin_clack_req.read()) Index: /branches/RWT/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd =================================================================== --- /branches/RWT/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd (revision 770) +++ /branches/RWT/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd (revision 771) @@ -40,5 +40,5 @@ Uses('caba:generic_fifo'), Uses('caba:generic_llsc_global_table'), - Uses('caba:dspin_dhccp_param') + Uses('caba:dspin_rwt_param') ], Index: /branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h =================================================================== --- /branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h (revision 770) +++ /branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h (revision 771) @@ -51,5 +51,5 @@ #include "update_tab.h" #include "dspin_interface.h" -#include "dspin_dhccp_param.h" +#include "dspin_rwt_param.h" #define TRT_ENTRIES 4 // Number of entries in TRT Index: /branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp =================================================================== --- /branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp (revision 770) +++ /branches/RWT/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp (revision 771) @@ -2029,6 +2029,6 @@ { uint64_t flit = m_cc_receive_to_multi_ack_fifo.read(); - updt_index = DspinDhccpParam::dspin_get(flit, - DspinDhccpParam::MULTI_ACK_UPDT_INDEX); + updt_index = DspinRwtParam::dspin_get(flit, + DspinRwtParam::MULTI_ACK_UPDT_INDEX); cc_receive_to_multi_ack_fifo_get = true; @@ -5661,29 +5661,29 @@ uint32_t srcid = - DspinDhccpParam::dspin_get( + DspinRwtParam::dspin_get( flit, - DspinDhccpParam::CLEANUP_SRCID); + DspinRwtParam::CLEANUP_SRCID); uint8_t type = - DspinDhccpParam::dspin_get( + DspinRwtParam::dspin_get( flit, - DspinDhccpParam::P2M_TYPE); + DspinRwtParam::P2M_TYPE); r_cleanup_way_index = - DspinDhccpParam::dspin_get( + DspinRwtParam::dspin_get( flit, - DspinDhccpParam::CLEANUP_WAY_INDEX); + DspinRwtParam::CLEANUP_WAY_INDEX); r_cleanup_nline = - DspinDhccpParam::dspin_get( + DspinRwtParam::dspin_get( flit, - DspinDhccpParam::CLEANUP_NLINE_MSB) << 32; - - r_cleanup_inst = (type == DspinDhccpParam::TYPE_CLEANUP_INST); + DspinRwtParam::CLEANUP_NLINE_MSB) << 32; + + r_cleanup_inst = (type == DspinRwtParam::TYPE_CLEANUP_INST); r_cleanup_srcid = srcid; r_cleanup_ncc = - DspinDhccpParam::dspin_get( + DspinRwtParam::dspin_get( flit, - DspinDhccpParam::CLEANUP_NCC); + DspinRwtParam::CLEANUP_NCC); r_cleanup_contains_data = false; @@ -5710,8 +5710,8 @@ << " CLEANUP_IDLE> Cleanup request:" << std::hex << " / owner_id = " << srcid - << " / owner_ins = " << (type == DspinDhccpParam::TYPE_CLEANUP_INST) - << " / ncc = " << DspinDhccpParam::dspin_get( + << " / owner_ins = " << (type == DspinRwtParam::TYPE_CLEANUP_INST) + << " / ncc = " << DspinRwtParam::dspin_get( flit, - DspinDhccpParam::CLEANUP_NCC) + DspinRwtParam::CLEANUP_NCC) << std::endl; } @@ -5728,8 +5728,8 @@ addr_t nline = r_cleanup_nline.read() | - DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB); + DspinRwtParam::dspin_get(flit, DspinRwtParam::CLEANUP_NLINE_LSB); bool eop = - DspinDhccpParam::dspin_get(flit, DspinDhccpParam::P2M_EOP) == 0x1; + DspinRwtParam::dspin_get(flit, DspinRwtParam::P2M_EOP) == 0x1; if (! eop) @@ -5768,5 +5768,5 @@ uint32_t data = - DspinDhccpParam::dspin_get (flit, DspinDhccpParam::CLEANUP_DATA_UPDT); + DspinRwtParam::dspin_get (flit, DspinRwtParam::CLEANUP_DATA_UPDT); r_cleanup_data[r_cleanup_data_index] = data; @@ -8170,10 +8170,10 @@ uint8_t type = - DspinDhccpParam::dspin_get( + DspinRwtParam::dspin_get( p_dspin_p2m.data.read(), - DspinDhccpParam::P2M_TYPE); - - if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or - (type == DspinDhccpParam::TYPE_CLEANUP_INST)) + DspinRwtParam::P2M_TYPE); + + if((type == DspinRwtParam::TYPE_CLEANUP_DATA) or + (type == DspinRwtParam::TYPE_CLEANUP_INST)) { r_cc_receive_fsm = CC_RECEIVE_CLEANUP; @@ -8181,5 +8181,5 @@ } - if(type == DspinDhccpParam::TYPE_MULTI_ACK) + if(type == DspinRwtParam::TYPE_MULTI_ACK) { r_cc_receive_fsm = CC_RECEIVE_MULTI_ACK; @@ -10261,31 +10261,31 @@ if(m_config_to_cc_send_inst_fifo.read()) { - multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST; + multi_inval_type = DspinRwtParam::TYPE_MULTI_INVAL_INST; } else { - multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA; + multi_inval_type = DspinRwtParam::TYPE_MULTI_INVAL_DATA; } uint64_t flit = 0; uint64_t dest = m_config_to_cc_send_srcid_fifo.read() << - (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S); - - DspinDhccpParam::dspin_set( flit, + (DspinRwtParam::SRCID_WIDTH - vci_param_int::S); + + DspinRwtParam::dspin_set( flit, dest, - DspinDhccpParam::MULTI_INVAL_DEST); + DspinRwtParam::MULTI_INVAL_DEST); // MODIFIED FOR CONFIG INVAL (solution 1 bit in flit multi_inval) - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, 1, - DspinDhccpParam::MULTI_INVAL_IS_CONFIG); - - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::MULTI_INVAL_IS_CONFIG); + + DspinRwtParam::dspin_set( flit, r_config_to_cc_send_trdid.read(), - DspinDhccpParam::MULTI_INVAL_UPDT_INDEX); - - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::MULTI_INVAL_UPDT_INDEX); + + DspinRwtParam::dspin_set( flit, multi_inval_type, - DspinDhccpParam::M2P_TYPE); + DspinRwtParam::M2P_TYPE); p_dspin_m2p.write = true; p_dspin_m2p.data = flit; @@ -10296,7 +10296,7 @@ { uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, r_config_to_cc_send_nline.read(), - DspinDhccpParam::MULTI_INVAL_NLINE); + DspinRwtParam::MULTI_INVAL_NLINE); p_dspin_m2p.eop = true; p_dspin_m2p.write = true; @@ -10312,26 +10312,26 @@ if(m_xram_rsp_to_cc_send_inst_fifo.read()) { - multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST; + multi_inval_type = DspinRwtParam::TYPE_MULTI_INVAL_INST; } else { - multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA; + multi_inval_type = DspinRwtParam::TYPE_MULTI_INVAL_DATA; } uint64_t flit = 0; uint64_t dest = m_xram_rsp_to_cc_send_srcid_fifo.read() << - (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S); - - DspinDhccpParam::dspin_set( flit, + (DspinRwtParam::SRCID_WIDTH - vci_param_int::S); + + DspinRwtParam::dspin_set( flit, dest, - DspinDhccpParam::MULTI_INVAL_DEST); - - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::MULTI_INVAL_DEST); + + DspinRwtParam::dspin_set( flit, r_xram_rsp_to_cc_send_trdid.read(), - DspinDhccpParam::MULTI_INVAL_UPDT_INDEX); - - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::MULTI_INVAL_UPDT_INDEX); + + DspinRwtParam::dspin_set( flit, multi_inval_type, - DspinDhccpParam::M2P_TYPE); + DspinRwtParam::M2P_TYPE); p_dspin_m2p.write = true; p_dspin_m2p.data = flit; @@ -10344,7 +10344,7 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, r_xram_rsp_to_cc_send_nline.read(), - DspinDhccpParam::MULTI_INVAL_NLINE); + DspinRwtParam::MULTI_INVAL_NLINE); p_dspin_m2p.eop = true; p_dspin_m2p.write = true; @@ -10358,15 +10358,15 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, m_broadcast_boundaries, - DspinDhccpParam::BROADCAST_BOX); + DspinRwtParam::BROADCAST_BOX); - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, 1, - DspinDhccpParam::MULTI_INVAL_IS_CONFIG); - - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::MULTI_INVAL_IS_CONFIG); + + DspinRwtParam::dspin_set( flit, 1ULL, - DspinDhccpParam::M2P_BC); + DspinRwtParam::M2P_BC); p_dspin_m2p.write = true; p_dspin_m2p.data = flit; @@ -10380,11 +10380,11 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, m_broadcast_boundaries, - DspinDhccpParam::BROADCAST_BOX); - - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::BROADCAST_BOX); + + DspinRwtParam::dspin_set( flit, 1ULL, - DspinDhccpParam::M2P_BC); + DspinRwtParam::M2P_BC); p_dspin_m2p.write = true; p_dspin_m2p.data = flit; @@ -10395,7 +10395,7 @@ { uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, r_xram_rsp_to_cc_send_nline.read(), - DspinDhccpParam::BROADCAST_NLINE); + DspinRwtParam::BROADCAST_NLINE); p_dspin_m2p.write = true; p_dspin_m2p.eop = true; @@ -10407,7 +10407,7 @@ { uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, r_config_to_cc_send_nline.read(), - DspinDhccpParam::BROADCAST_NLINE); + DspinRwtParam::BROADCAST_NLINE); p_dspin_m2p.write = true; p_dspin_m2p.eop = true; @@ -10421,23 +10421,23 @@ uint64_t flit = 0; - uint8_t multi_inval_type; - if (r_read_to_cc_send_inst.read()) - { - multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST; - } - else - { - multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA; - } - - DspinDhccpParam::dspin_set( + //uint8_t multi_inval_type; + //if (r_read_to_cc_send_inst.read()) + //{ + // multi_inval_type = DspinRwtParam::TYPE_MULTI_INVAL_INST; + //} + //else + //{ + // multi_inval_type = DspinRwtParam::TYPE_MULTI_INVAL_DATA; + //} + + DspinRwtParam::dspin_set( flit, r_read_to_cc_send_dest.read(), - DspinDhccpParam::MULTI_INVAL_DEST); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_INVAL_DEST); + + DspinRwtParam::dspin_set( flit, - DspinDhccpParam::TYPE_MULTI_INVAL_DATA, - DspinDhccpParam::M2P_TYPE); + DspinRwtParam::TYPE_MULTI_INVAL_DATA, + DspinRwtParam::M2P_TYPE); p_dspin_m2p.write = true; @@ -10453,8 +10453,8 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, r_read_to_cc_send_nline.read(), - DspinDhccpParam::MULTI_INVAL_NLINE); + DspinRwtParam::MULTI_INVAL_NLINE); @@ -10471,13 +10471,13 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, r_write_to_cc_send_dest.read(), - DspinDhccpParam::MULTI_INVAL_DEST); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_INVAL_DEST); + + DspinRwtParam::dspin_set( flit, - DspinDhccpParam::TYPE_MULTI_INVAL_DATA, - DspinDhccpParam::M2P_TYPE); + DspinRwtParam::TYPE_MULTI_INVAL_DATA, + DspinRwtParam::M2P_TYPE); p_dspin_m2p.write = true; @@ -10492,8 +10492,8 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, r_write_to_cc_send_nline.read(), - DspinDhccpParam::MULTI_INVAL_NLINE); + DspinRwtParam::MULTI_INVAL_NLINE); @@ -10510,7 +10510,7 @@ { uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, r_write_to_cc_send_nline.read(), - DspinDhccpParam::BROADCAST_NLINE); + DspinRwtParam::BROADCAST_NLINE); p_dspin_m2p.write = true; p_dspin_m2p.eop = true; @@ -10522,7 +10522,7 @@ { uint64_t flit = 0; - DspinDhccpParam::dspin_set( flit, + DspinRwtParam::dspin_set( flit, r_cas_to_cc_send_nline.read(), - DspinDhccpParam::BROADCAST_NLINE); + DspinRwtParam::BROADCAST_NLINE); p_dspin_m2p.write = true; p_dspin_m2p.eop = true; @@ -10538,9 +10538,9 @@ if(m_write_to_cc_send_inst_fifo.read()) { - multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_INST; + multi_updt_type = DspinRwtParam::TYPE_MULTI_UPDT_INST; } else { - multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_DATA; + multi_updt_type = DspinRwtParam::TYPE_MULTI_UPDT_DATA; } @@ -10548,20 +10548,20 @@ uint64_t dest = m_write_to_cc_send_srcid_fifo.read() << - (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S); - - DspinDhccpParam::dspin_set( + (DspinRwtParam::SRCID_WIDTH - vci_param_int::S); + + DspinRwtParam::dspin_set( flit, dest, - DspinDhccpParam::MULTI_UPDT_DEST); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_DEST); + + DspinRwtParam::dspin_set( flit, r_write_to_cc_send_trdid.read(), - DspinDhccpParam::MULTI_UPDT_UPDT_INDEX); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_UPDT_INDEX); + + DspinRwtParam::dspin_set( flit, multi_updt_type, - DspinDhccpParam::M2P_TYPE); + DspinRwtParam::M2P_TYPE); p_dspin_m2p.write = true; @@ -10575,13 +10575,13 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, r_write_to_cc_send_index.read(), - DspinDhccpParam::MULTI_UPDT_WORD_INDEX); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_WORD_INDEX); + + DspinRwtParam::dspin_set( flit, r_write_to_cc_send_nline.read(), - DspinDhccpParam::MULTI_UPDT_NLINE); + DspinRwtParam::MULTI_UPDT_NLINE); p_dspin_m2p.write = true; @@ -10602,13 +10602,13 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, multi_updt_be, - DspinDhccpParam::MULTI_UPDT_BE); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_BE); + + DspinRwtParam::dspin_set( flit, multi_updt_data, - DspinDhccpParam::MULTI_UPDT_DATA); + DspinRwtParam::MULTI_UPDT_DATA); p_dspin_m2p.write = true; @@ -10626,9 +10626,9 @@ if(m_cas_to_cc_send_inst_fifo.read()) { - multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_INST; + multi_updt_type = DspinRwtParam::TYPE_MULTI_UPDT_INST; } else { - multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_DATA; + multi_updt_type = DspinRwtParam::TYPE_MULTI_UPDT_DATA; } @@ -10636,20 +10636,20 @@ uint64_t dest = m_cas_to_cc_send_srcid_fifo.read() << - (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S); - - DspinDhccpParam::dspin_set( + (DspinRwtParam::SRCID_WIDTH - vci_param_int::S); + + DspinRwtParam::dspin_set( flit, dest, - DspinDhccpParam::MULTI_UPDT_DEST); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_DEST); + + DspinRwtParam::dspin_set( flit, r_cas_to_cc_send_trdid.read(), - DspinDhccpParam::MULTI_UPDT_UPDT_INDEX); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_UPDT_INDEX); + + DspinRwtParam::dspin_set( flit, multi_updt_type, - DspinDhccpParam::M2P_TYPE); + DspinRwtParam::M2P_TYPE); p_dspin_m2p.write = true; @@ -10663,13 +10663,13 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, r_cas_to_cc_send_index.read(), - DspinDhccpParam::MULTI_UPDT_WORD_INDEX); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_WORD_INDEX); + + DspinRwtParam::dspin_set( flit, r_cas_to_cc_send_nline.read(), - DspinDhccpParam::MULTI_UPDT_NLINE); + DspinRwtParam::MULTI_UPDT_NLINE); p_dspin_m2p.write = true; @@ -10683,13 +10683,13 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, 0xF, - DspinDhccpParam::MULTI_UPDT_BE); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_BE); + + DspinRwtParam::dspin_set( flit, r_cas_to_cc_send_wdata.read(), - DspinDhccpParam::MULTI_UPDT_DATA); + DspinRwtParam::MULTI_UPDT_DATA); p_dspin_m2p.write = true; @@ -10704,13 +10704,13 @@ uint64_t flit = 0; - DspinDhccpParam::dspin_set( + DspinRwtParam::dspin_set( flit, 0xF, - DspinDhccpParam::MULTI_UPDT_BE); - - DspinDhccpParam::dspin_set( + DspinRwtParam::MULTI_UPDT_BE); + + DspinRwtParam::dspin_set( flit, r_cas_to_cc_send_wdata_high.read(), - DspinDhccpParam::MULTI_UPDT_DATA); + DspinRwtParam::MULTI_UPDT_DATA); p_dspin_m2p.write = true; @@ -10731,34 +10731,34 @@ if(r_cleanup_inst.read()) { - cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST; + cleanup_ack_type = DspinRwtParam::TYPE_CLACK_INST; } else { - cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA; + cleanup_ack_type = DspinRwtParam::TYPE_CLACK_DATA; } uint64_t flit = 0; uint64_t dest = r_cleanup_srcid.read() << - (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S); - - DspinDhccpParam::dspin_set( + (DspinRwtParam::SRCID_WIDTH - vci_param_int::S); + + DspinRwtParam::dspin_set( flit, dest, - DspinDhccpParam::CLACK_DEST); - - DspinDhccpParam::dspin_set( + DspinRwtParam::CLACK_DEST); + + DspinRwtParam::dspin_set( flit, r_cleanup_nline.read() & 0xFFFF, - DspinDhccpParam::CLACK_SET); - - DspinDhccpParam::dspin_set( + DspinRwtParam::CLACK_SET); + + DspinRwtParam::dspin_set( flit, r_cleanup_way_index.read(), - DspinDhccpParam::CLACK_WAY); - - DspinDhccpParam::dspin_set( + DspinRwtParam::CLACK_WAY); + + DspinRwtParam::dspin_set( flit, cleanup_ack_type, - DspinDhccpParam::CLACK_TYPE); + DspinRwtParam::CLACK_TYPE); p_dspin_clack.eop = true;