From c1aabe8172215c293f3540bce08739b22871d538 Mon Sep 17 00:00:00 2001 From: Nathan Binkert Date: Tue, 1 Jun 2010 11:38:56 -0700 Subject: [PATCH] style: clean up ruby's Set class Further cleanup should probably be done to make this class be non-Ruby specific and put it in src/base. There are probably several cases where this class is used, std::bitset could be used instead. --- src/mem/ruby/common/NetDest.cc | 2 +- src/mem/ruby/common/Set.cc | 657 +++++++++++---------------------- src/mem/ruby/common/Set.hh | 212 ++++------- 3 files changed, 304 insertions(+), 567 deletions(-) diff --git a/src/mem/ruby/common/NetDest.cc b/src/mem/ruby/common/NetDest.cc index f694af99b..509d0d223 100644 --- a/src/mem/ruby/common/NetDest.cc +++ b/src/mem/ruby/common/NetDest.cc @@ -222,7 +222,7 @@ NetDest::intersectionIsNotEmpty(const NetDest& other_netDest) const { assert(m_bits.size() == other_netDest.getSize()); for (int i = 0; i < m_bits.size(); i++) { - if (m_bits[i].intersectionIsNotEmpty(other_netDest.m_bits[i])) { + if (!m_bits[i].intersectionIsEmpty(other_netDest.m_bits[i])) { return true; } } diff --git a/src/mem/ruby/common/Set.cc b/src/mem/ruby/common/Set.cc index a9ced0078..c946fec16 100644 --- a/src/mem/ruby/common/Set.cc +++ b/src/mem/ruby/common/Set.cc @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,554 +26,340 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * Set.cc - * - * Description: See Set.hh - * - * $Id: BigSet.cc 1.9 05/01/19 13:12:25-06:00 mikem@maya.cs.wisc.edu $ - * - */ - -// modified (rewritten) 05/20/05 by Dan Gibson to accomimdate FASTER >32 bit -// set sizes +// modified (rewritten) 05/20/05 by Dan Gibson to accomimdate FASTER +// >32 bit set sizes #include "mem/ruby/common/Set.hh" #include "mem/ruby/system/System.hh" -#if __amd64__ || __LP64__ -#define __64BITS__ -#else -#define __32BITS__ -#endif - Set::Set() { - m_p_nArray = NULL; - m_nArrayLen = 0; - m_nSize = 0; + m_p_nArray = NULL; + m_nArrayLen = 0; + m_nSize = 0; } -// copy constructor -Set::Set(const Set& obj) { - m_p_nArray = NULL; - setSize(obj.m_nSize); - - // copy from the host to this array - for(int i=0; i 0) { - setSize(size); - } + m_p_nArray = NULL; + m_nArrayLen = 0; + m_nSize = 0; + if (size > 0) + setSize(size); } -Set::~Set() { - if( (m_p_nArray != (&m_p_nArray_Static[0])) && (m_p_nArray != NULL)) - delete [] m_p_nArray; - m_p_nArray = NULL; -} - - -// /* -// * This function should set the bit corresponding to index -// * to 1. -// */ - -// void Set::add(NodeID index) -// { -// assert(index= 0); - -// #ifdef __32BITS__ -// m_p_nArray[index>>5] |= (1 << (index & 0x01F)); -// #else -// m_p_nArray[index>>6] |= (((unsigned long) 1) << (index & 0x03F)); -// #endif // __32BITS__ - -// } - -/* - * This function should set all the bits in the current set - * that are already set in the parameter set - */ -void Set::addSet(const Set& set) +Set::~Set() { - assert(getSize()==set.getSize()); - for(int i=0; i> 1; - } - } + // now just ensure that no bits over the maximum size were set +#ifdef _LP64 + long mask = 0x7FFFFFFFFFFFFFFF; #else - long mask = 0x7FFFFFFFFFFFFFFF; + long mask = 0x7FFFFFFF; +#endif - // the number of populated spaces in the higest-order array slot is: - // m_nSize % 64, so the uppermost 64 - m_nSize%64 bits should be - // cleared - - if((m_nSize % 64) != 0) { - for(int j=0; j<64-(m_nSize&0x03F); j++) { - m_p_nArray[m_nArrayLen-1] &= mask; - mask = mask >> 1; + // the number of populated spaces in the higest-order array slot + // is: m_nSize % LONG_BITS, so the uppermost LONG_BITS - + // m_nSize%64 bits should be cleared + if ((m_nSize % LONG_BITS) != 0) { + for (int j = 0; j < 64 - (m_nSize & INDEX_MASK); j++) { + m_p_nArray[m_nArrayLen - 1] &= mask; + mask = mask >> 1; + } } - } -#endif // __32BITS__ - } -// /* -// * This function unsets the bit associated with index -// */ -// void Set::remove(NodeID index) -// { -// assert(index=0); -// #ifdef __32BITS__ -// m_p_nArray[index>>5] &= ~(0x00000001 << (index & 0x01F)); -// #else -// m_p_nArray[index>>6] &= ~(((unsigned long) 0x0000000000000001) << (index & 0x03F)); -// #endif // __32BITS__ +/* + * This function should set all the bits in the current set that are + * already set in the parameter set + */ +void +Set::addSet(const Set& set) +{ + assert(getSize()==set.getSize()); + for (int i = 0; i < m_nArrayLen; i++) + m_p_nArray[i] |= set.m_p_nArray[i]; +} -// } +/* + * This function should randomly assign 1 to the bits in the set--it + * should not clear the bits bits first, though? + */ +void +Set::addRandom() +{ + for (int i = 0; i < m_nArrayLen; i++) { + // this ensures that all 32 bits are subject to random effects, + // as RAND_MAX typically = 0x7FFFFFFF + m_p_nArray[i] |= random() ^ (random() << 4); + } + clearExcess(); +} /* * This function clears bits that are =1 in the parameter set */ -void Set::removeSet(const Set& set) +void +Set::removeSet(const Set& set) { - - assert(m_nSize==set.m_nSize); - for(int i=0; i> 1; - } - } -#else - long mask = 0x7FFFFFFFFFFFFFFF; - - // the number of populated spaces in the higest-order array slot is: - // m_nSize % 64, so the uppermost 64 - m_nSize%64 bits should be - // cleared - - if((m_nSize % 64) != 0) { - for(int j=0; j<64-(m_nSize&0x03F); j++) { - m_p_nArray[m_nArrayLen-1] &= mask; - mask = mask >> 1; - } - } -#endif // __32BITS__ - + clearExcess(); } /* * This function returns the population count of 1's in the set */ -int Set::count() const +int +Set::count() const { - int counter = 0; - long mask; - for( int i=0; i 0); - long x; - for( int i=0; i 0); + long x; + for (int i = 0; i < m_nArrayLen; i++) { + if (m_p_nArray[i] != 0) { + // the least-set bit must be in here + x = m_p_nArray[i]; -#ifdef __32BITS__ - for( int j=0; j<32; j++) { - if(x & 0x00000001) { - return 32*i+j; + for (int j = 0; j < LONG_BITS; j++) { + if (x & (unsigned long)1) { + return LONG_BITS * i + j; + } + + x = x >> 1; + } + + ERROR_MSG("No smallest element of an empty set."); } - - x = x >> 1; - } -#else - for( int j=0; j<64; j++) { - if(x & 0x0000000000000001) { - return 64*i+j; - } - - x = x >> 1; - } -#endif // __32BITS__ - - ERROR_MSG("No smallest element of an empty set."); } - } - ERROR_MSG("No smallest element of an empty set."); + ERROR_MSG("No smallest element of an empty set."); - return 0; + return 0; } /* * this function returns true iff all bits are set */ -bool Set::isBroadcast() const +bool +Set::isBroadcast() const { - // check the fully-loaded words by equal to 0xffffffff - // only the last word may not be fully loaded, it is not - // fully loaded iff m_nSize % 32 or 64 !=0 => fully loaded iff - // m_nSize % 32 or 64 == 0 + // check the fully-loaded words by equal to 0xffffffff + // only the last word may not be fully loaded, it is not + // fully loaded iff m_nSize % 32 or 64 !=0 => fully loaded iff + // m_nSize % 32 or 64 == 0 -#ifdef __32BITS__ - for(int i=0; i< (((m_nSize % 32)==0) ? m_nArrayLen : m_nArrayLen-1); i++) { - if(m_p_nArray[i]!=-1) { - return false; + int max = (m_nSize % LONG_BITS) == 0 ? m_nArrayLen : m_nArrayLen - 1; + for (int i = 0; i < max; i++) { + if (m_p_nArray[i] != -1) { + return false; + } } - } - // now check the last word, which may not be fully loaded - long mask = 1; - for(int j=0; j< (m_nSize % 32); j++) { - if((mask & m_p_nArray[m_nArrayLen-1])==0) { - return false; + // now check the last word, which may not be fully loaded + long mask = 1; + for (int j = 0; j < (m_nSize % LONG_BITS); j++) { + if ((mask & m_p_nArray[m_nArrayLen-1]) == 0) { + return false; + } + mask = mask << 1; } - mask = mask << 1; - } -#else - for(int i=0; i< (((m_nSize % 64)==0) ? m_nArrayLen : m_nArrayLen-1); i++) { - if(m_p_nArray[i]!=-1) { - return false; - } - } - // now check the last word, which may not be fully loaded - long mask = 1; - for(int j=0; j< (m_nSize % 64); j++) { - if((mask & m_p_nArray[m_nArrayLen-1])==0) { - return false; - } - mask = mask << 1; - } - -#endif // __32BITS__ - - return true; + return true; } /* * this function returns true iff no bits are set */ -bool Set::isEmpty() const +bool +Set::isEmpty() const { - - // here we can simply check if all = 0, since we ensure - // that "extra slots" are all zero - for(int i=0; i< m_nArrayLen ; i++) { - if(m_p_nArray[i]!=0) { + // here we can simply check if all = 0, since we ensure + // that "extra slots" are all zero + for (int i = 0; i < m_nArrayLen ; i++) + if (m_p_nArray[i]) return false; - } - } - return true; + return true; } // returns the logical OR of "this" set and orSet -Set Set::OR(const Set& orSet) const +Set +Set::OR(const Set& orSet) const { - Set result(m_nSize); - assert(m_nSize == orSet.m_nSize); - for(int i=0; i< m_nArrayLen; i++) { - result.m_p_nArray[i] = m_p_nArray[i] | orSet.m_p_nArray[i]; - } - - return result; + Set result(m_nSize); + assert(m_nSize == orSet.m_nSize); + for (int i = 0; i < m_nArrayLen; i++) + result.m_p_nArray[i] = m_p_nArray[i] | orSet.m_p_nArray[i]; + return result; } // returns the logical AND of "this" set and andSet -Set Set::AND(const Set& andSet) const +Set +Set::AND(const Set& andSet) const { - Set result(m_nSize); - assert(m_nSize == andSet.m_nSize); + Set result(m_nSize); + assert(m_nSize == andSet.m_nSize); - for(int i=0; i< m_nArrayLen; i++) { - result.m_p_nArray[i] = m_p_nArray[i] & andSet.m_p_nArray[i]; - } + for (int i = 0; i < m_nArrayLen; i++) { + result.m_p_nArray[i] = m_p_nArray[i] & andSet.m_p_nArray[i]; + } - return result; + return result; } -// // Returns true if the intersection of the two sets is non-empty -// bool Set::intersectionIsNotEmpty(const Set& other_set) const -// { -// assert(m_nSize == other_set.m_nSize); -// for(int i=0; i< m_nArrayLen; i++) { -// if(m_p_nArray[i] & other_set.m_p_nArray[i]) { -// return true; -// } -// } - -// return false; - -// } - -// // Returns true if the intersection of the two sets is empty -// bool Set::intersectionIsEmpty(const Set& other_set) const -// { -// assert(m_nSize == other_set.m_nSize); -// for(int i=0; i< m_nArrayLen; i++) { -// if(m_p_nArray[i] & other_set.m_p_nArray[i]) { -// return false; -// } -// } - -// return true; - -// } - /* - * Returns false if a bit is set in the parameter set that is - * NOT set in this set + * Returns false if a bit is set in the parameter set that is NOT set + * in this set */ -bool Set::isSuperset(const Set& test) const +bool +Set::isSuperset(const Set& test) const { - assert(m_nSize == test.m_nSize); + assert(m_nSize == test.m_nSize); - for(int i=0;i>5] & (0x00000001 << (element & 0x01F)))!=0); -// #else -// result = ((m_p_nArray[element>>6] & (((unsigned long) 0x0000000000000001) << (element & 0x03F)))!=0); -// #endif // __32BITS__ - -// return result; -// } - -/* - * "Supposed" to return the node id of the (n+1)th set - * bit, IE n=0 => returns nodeid of first set bit, BUT - * since BigSet.cc behaves strangely, this implementation - * will behave strangely just for reverse compatability. - * - * Was originally implemented for the flight data recorder - * FDR - */ - -// NodeID Set::elementAt(int n) const -// { -// if(isElement(n)) return (NodeID) true; -// else return 0; - -// /* -// int match = -1; -// for(int i=0;i=0; i--) { -#ifdef __32BITS__ - sprintf(buff,"%08X ",m_p_nArray[i]); + if (!m_p_nArray) { + out << "[Set {Empty}]"; + return; + } + + char buff[24]; + out << "[Set (" << m_nSize << ") 0x "; + for (int i = m_nArrayLen - 1; i >= 0; i--) { +#ifdef _LP64 + sprintf(buff,"0x %016llX ", (long long)m_p_nArray[i]); #else - sprintf(buff,"0x %016llX ", (long long)m_p_nArray[i]); + sprintf(buff,"%08X ", m_p_nArray[i]); #endif // __32BITS__ - out << buff; - } - out << " ]"; - + out << buff; + } + out << " ]"; } - - diff --git a/src/mem/ruby/common/Set.hh b/src/mem/ruby/common/Set.hh index d0660c6e6..a0178178a 100644 --- a/src/mem/ruby/common/Set.hh +++ b/src/mem/ruby/common/Set.hh @@ -1,4 +1,3 @@ - /* * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood * All rights reserved. @@ -27,178 +26,131 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * Set.hh - * - * Description: - * - * $Id: BigSet.hh 1.6 05/01/19 13:12:25-06:00 mikem@maya.cs.wisc.edu $ - * - */ - // modified by Dan Gibson on 05/20/05 to accomidate FASTER // >32 set lengths, using an array of ints w/ 32 bits/int -// NOTE: Never include this file directly, this should only be -// included from Set.hh - -#ifndef SET_H -#define SET_H +#ifndef __MEM_RUBY_COMMON_SET_HH__ +#define __MEM_RUBY_COMMON_SET_HH__ #include +#include #include "mem/ruby/system/System.hh" #include "mem/ruby/common/Global.hh" -#include "mem/gems_common/Vector.hh" #include "mem/ruby/system/NodeID.hh" -// gibson 05/20/05 -// enum PresenceBit {NotPresent, Present}; +class Set +{ + private: + int m_nSize; // the number of bits in this set + int m_nArrayLen; // the number of 32-bit words that are + // held in the array -class Set { -public: - // Constructors - // creates and empty set - Set(); - Set (int size); + // Changed 5/24/05 for static allocation of array + // note that "long" corresponds to 32 bits on a 32-bit machine, + // 64 bits if the -m64 parameter is passed to g++, which it is + // for an AMD opteron under our configuration - // used during the replay mechanism - // Set(const char *str); + long *m_p_nArray; // an word array to hold the bits in the set + long m_p_nArray_Static[NUMBER_WORDS_PER_SET]; - Set(const Set& obj); - Set& operator=(const Set& obj); + static const int LONG_BITS = std::numeric_limits::digits; + static const int INDEX_SHIFT = LONG_BITS == 64 ? 6 : 5; + static const int INDEX_MASK = (1 << INDEX_SHIFT) - 1; - // Destructor - ~Set(); + void clearExcess(); - // Public Methods + public: + Set(); + Set(int size); + Set(const Set& obj); + ~Set(); - inline void add(NodeID index) + Set& operator=(const Set& obj); + + void + add(NodeID index) { -#ifdef __32BITS__ - m_p_nArray[index>>5] |= (1 << (index & 0x01F)); -#else - m_p_nArray[index>>6] |= (((unsigned long) 1) << (index & 0x03F)); -#endif // __32BITS__ + m_p_nArray[index >> INDEX_SHIFT] |= + (((unsigned long) 1) << (index & INDEX_MASK)); } - void addSet(const Set& set); - void addRandom(); + void addSet(const Set& set); + void addRandom(); - inline void remove(NodeID index) + void + remove(NodeID index) { -#ifdef __32BITS__ - m_p_nArray[index>>5] &= ~(0x00000001 << (index & 0x01F)); -#else - m_p_nArray[index>>6] &= ~(((unsigned long) 0x0000000000000001) << (index & 0x03F)); -#endif // __32BITS__ + m_p_nArray[index >> INDEX_SHIFT] &= + ~(((unsigned long)1) << (index & INDEX_MASK)); } + void removeSet(const Set& set); - void removeSet(const Set& set); - - inline void clear() { for(int i=0; i>5] & (0x00000001 << (element & 0x01F)))!=0); -#else - return ((m_p_nArray[element>>6] & (((unsigned long) 0x0000000000000001) << (element & 0x03F)))!=0); -#endif // __32BITS__ - + return (m_p_nArray[element>>INDEX_SHIFT] & + (((unsigned long)1) << (element & INDEX_MASK))) != 0; } - bool isBroadcast() const; - bool isEmpty() const; + bool isBroadcast() const; + bool isEmpty() const; - NodeID smallestElement() const; + NodeID smallestElement() const; - // int size() const; - void setSize (int size); + void setSize(int size); - // get element for a index - inline NodeID elementAt(int index) const + NodeID + elementAt(int index) const { - if(isElement(index)) return (NodeID) true; - else return 0; + if (isElement(index)) + return (NodeID)true; + else + return 0; } - // gibson 05/20/05 - int getSize() const { return m_nSize; } + int getSize() const { return m_nSize; } - // DEPRECATED METHODS - void addToSet(NodeID newElement) { add(newElement); } // Deprecated - void removeFromSet(NodeID newElement) { remove(newElement); } // Deprecated - void clearSet() { clear(); } // Deprecated - void setBroadcast() { broadcast(); } // Deprecated - bool presentInSet(NodeID element) const { return isElement(element); } // Deprecated - - void print(std::ostream& out) const; -private: - // Private Methods - - // Data Members (m_ prefix) - // gibson 05/20/05 - // Vector m_bits; // This is an vector of uint8 to reduce the size of the set - - int m_nSize; // the number of bits in this set - int m_nArrayLen; // the number of 32-bit words that are held in the array - - // Changed 5/24/05 for static allocation of array - // note that "long" corresponds to 32 bits on a 32-bit machine, - // 64 bits if the -m64 parameter is passed to g++, which it is - // for an AMD opteron under our configuration - - long * m_p_nArray; // an word array to hold the bits in the set - long m_p_nArray_Static[NUMBER_WORDS_PER_SET]; + void print(std::ostream& out) const; }; -// Output operator declaration -std::ostream& operator<<(std::ostream& out, const Set& obj); - -// ******************* Definitions ******************* - -// Output operator definition -extern inline -std::ostream& operator<<(std::ostream& out, const Set& obj) +inline std::ostream& +operator<<(std::ostream& out, const Set& obj) { - obj.print(out); - out << std::flush; - return out; + obj.print(out); + out << std::flush; + return out; } -#endif //SET_H - +#endif // __MEM_RUBY_COMMON_SET_HH__