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.

3 files changed, 300 insertions, 563 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<m_nArrayLen; i++) {
-    m_p_nArray[i] = obj.m_p_nArray[i];
-  }
+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 < m_nArrayLen; i++)
+        m_p_nArray[i] = obj.m_p_nArray[i];
 }
 
 Set::Set(int size)
 {
-  m_p_nArray = NULL;
-  m_nArrayLen = 0;
-  m_nSize = 0;
-  if(size > 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;
+Set::~Set()
+{
+    if (m_p_nArray && m_p_nArray != &m_p_nArray_Static[0])
+        delete [] m_p_nArray;
+    m_p_nArray = NULL;
 }
 
+void
+Set::clearExcess()
+{
+    // now just ensure that no bits over the maximum size were set
+#ifdef _LP64
+    long mask = 0x7FFFFFFFFFFFFFFF;
+#else
+    long mask = 0x7FFFFFFF;
+#endif
 
-// /*
-//  * This function should set the bit corresponding to index
-//  * to 1.
-//  */
-
-// void Set::add(NodeID index)
-// {
-//   assert(index<m_nSize && 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__
+    // 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;
+        }
+    }
+}
 
-// }
 
 /*
- * This function should set all the bits in the current set
- * that are already set in the parameter set
+ * 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)
+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];
-  }
-
+    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?
+ * This function should randomly assign 1 to the bits in the set--it
+ * should not clear the bits bits first, though?
  */
-void Set::addRandom()
+void
+Set::addRandom()
 {
 
-  for(int i=0; i<m_nArrayLen; i++) {
-    m_p_nArray[i] |= random() ^ (random() << 4); // this ensures that all 32 bits are subject to random effects,
-                                                 // as RAND_MAX typically = 0x7FFFFFFF
-  }
-
-  // now just ensure that no bits over the maximum size were set
-#ifdef __32BITS__
-  long mask = 0x7FFFFFFF;
-
-  // the number of populated spaces in the higest-order array slot is:
-  // m_nSize % 32, so the uppermost 32 - m_nSize%32 bits should be
-  // cleared
-
-  if((m_nSize % 32) != 0) {
-    for(int j=0; j<32-(m_nSize&0x01F); j++) {
-      m_p_nArray[m_nArrayLen-1] &= mask;
-      mask = mask >> 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;
+    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);
     }
-  }
-#endif // __32BITS__
-
+    clearExcess();
 }
 
-// /*
-//  * This function unsets the bit associated with index
-//  */
-// void Set::remove(NodeID index)
-// {
-//   assert(index<m_nSize && 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 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<m_nArrayLen; i++) {
-    m_p_nArray[i] &= ~(set.m_p_nArray[i]);
-  }
-
+    assert(m_nSize == set.m_nSize);
+    for (int i = 0; i < m_nArrayLen; i++)
+        m_p_nArray[i] &= ~set.m_p_nArray[i];
 }
 
-// /*
-//  * This function clears all bits in the set
-//  */
-// void Set::clear()
-// {
-//   for(int i=0; i<m_nArrayLen; i++) {
-//     m_p_nArray[i] = 0;
-//   }
-// }
-
 /*
  * this function sets all bits in the set
  */
-void Set::broadcast()
+void
+Set::broadcast()
 {
+    for (int i = 0; i < m_nArrayLen; i++)
+        m_p_nArray[i] = -1; // note that -1 corresponds to all 1's in 2's comp.
 
-  for(int i=0; i<m_nArrayLen; i++) {
-    m_p_nArray[i] = -1; // note that -1 corresponds to all 1's in 2's comp.
-  }
-
-  // now just ensure that no bits over the maximum size were set
-#ifdef __32BITS__
-  long mask = 0x7FFFFFFF;
-
-  // the number of populated spaces in the higest-order array slot is:
-  // m_nSize % 32, so the uppermost 32 - m_nSize%32 bits should be
-  // cleared
-
-  if((m_nSize % 32) != 0) {
-    for(int j=0; j<32-(m_nSize&0x01F); j++) {
-      m_p_nArray[m_nArrayLen-1] &= mask;
-      mask = mask >> 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<m_nArrayLen; i++) {
-    mask = (long) 0x01;
-
-#ifdef __32BITS__
-    for( int j=0; j<32; j++) {
-      if(m_p_nArray[i] & mask) counter++;
-      mask = mask << 1;
-    }
-
-#else
-
-    for( int j=0; j<64; j++) {  // FIXME - significant performance loss when array population << 64
-      if((m_p_nArray[i] & mask) != 0) {
-              counter++;
-      }
-      mask = mask << 1;
+    int counter = 0;
+    long mask;
+
+    for (int i = 0; i < m_nArrayLen; i++) {
+        mask = (long)0x01;
+
+        for (int j = 0; j < LONG_BITS; j++) {
+            // FIXME - significant performance loss when array
+            // population << LONG_BITS
+            if ((m_p_nArray[i] & mask) != 0) {
+                counter++;
+            }
+            mask = mask << 1;
+        }
     }
 
-#endif // __32BITS__
-
-  }
-
-  return counter;
+    return counter;
 }
 
 /*
  * This function checks for set equality
  */
-
-bool Set::isEqual(const Set& set) const
+bool
+Set::isEqual(const Set& set) const
 {
-  assert(m_nSize==set.m_nSize);
+    assert(m_nSize == set.m_nSize);
 
-  for(int i=0;i<m_nArrayLen;i++) {
-    if(m_p_nArray[i] != set.m_p_nArray[i]) {
-      return false;
-    }
-  }
+    for (int i = 0; i < m_nArrayLen; i++)
+        if (m_p_nArray[i] != set.m_p_nArray[i])
+            return false;
 
-  return true;
+    return true;
 }
 
 /*
- * This function returns the NodeID (int) of the
- * least set bit
+ * This function returns the NodeID (int) of the least set bit
  */
-NodeID Set::smallestElement() const
+NodeID
+Set::smallestElement() const
 {
-  assert(count() > 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;
+    assert(count() > 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];
+
+            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
-
-#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;
-    }
-  }
-
-  // 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;
-    }
-    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;
+    // 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
+
+    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 % 64); 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;
-  }
 
-#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<m_nArrayLen;i++) {
-    if(((test.m_p_nArray[i] & m_p_nArray[i]) | ~test.m_p_nArray[i]) != -1) {
-      return false;
-    }
-  }
+    for (int i = 0; i < m_nArrayLen; i++)
+        if (((test.m_p_nArray[i] & m_p_nArray[i]) | ~test.m_p_nArray[i]) != -1)
+            return false;
 
-  return true;
+    return true;
 }
 
-// /*
-//  * Returns true iff this bit is set
-//  */
-// bool Set::isElement(NodeID element) const
-// {
-//   bool result;
-
-// #ifdef __32BITS__
-//   result = ((m_p_nArray[element>>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<m_nSize;i++) {
-//     if(isElement(i)) match++;
-//     if(match==n) {
-//       return i;
-//     }
-//   }
-
-//   return -1;
-//   */
-// }
-
-void Set::setSize(int size)
+void
+Set::setSize(int size)
 {
-  m_nSize = size;
-
-#ifdef __32BITS__
-  m_nArrayLen = m_nSize/32 + ((m_nSize%32==0) ? 0 : 1 );
-#else
-  m_nArrayLen = m_nSize/64 + ((m_nSize%64==0) ? 0 : 1 );
-#endif // __32BITS__
-
-  // decide whether to use dynamic or static alloction
-  if(m_nArrayLen<=NUMBER_WORDS_PER_SET) { // constant defined in RubySystem.hh
-    // its OK to use the static allocation, and it will
-    // probably be faster (as m_nArrayLen is already in the
-    // cache and they will probably share the same cache line)
-
-    // if switching from dyanamic to static allocation (which
-    // is probably rare, but why not be complete?), must delete
-    // the dynamically allocated space
-    if((m_p_nArray != NULL) && (m_p_nArray != &m_p_nArray_Static[0]))
-      delete [] m_p_nArray;
-
-    m_p_nArray = & m_p_nArray_Static[0];
-  } else {
-
-    // can't use static allocation...simply not enough room
-    // so dynamically allocate some space
-    if((m_p_nArray != NULL) && (m_p_nArray != &m_p_nArray_Static[0]))
-      delete [] m_p_nArray;
-
-    m_p_nArray = new long[m_nArrayLen];
-  }
+    m_nSize = size;
+
+    m_nArrayLen = m_nSize / LONG_BITS + ((m_nSize % LONG_BITS == 0) ? 0 : 1 );
+
+    // decide whether to use dynamic or static alloction
+    if (m_nArrayLen <= NUMBER_WORDS_PER_SET) {
+        // constant defined in RubySystem.hh
+        // its OK to use the static allocation, and it will
+        // probably be faster (as m_nArrayLen is already in the
+        // cache and they will probably share the same cache line)
+
+        // if switching from dyanamic to static allocation (which
+        // is probably rare, but why not be complete?), must delete
+        // the dynamically allocated space
+        if (m_p_nArray && m_p_nArray != &m_p_nArray_Static[0])
+            delete [] m_p_nArray;
+
+        m_p_nArray = &m_p_nArray_Static[0];
+    } else {
+        // can't use static allocation...simply not enough room
+        // so dynamically allocate some space
+        if (m_p_nArray && m_p_nArray != &m_p_nArray_Static[0])
+            delete [] m_p_nArray;
+
+        m_p_nArray = new long[m_nArrayLen];
+    }
 
-  clear();
+    clear();
 }
 
-Set& Set::operator=(const Set& obj) {
-  if(this == &obj) {
-    // do nothing
-  } else {
-
-    // resize this item
-    setSize(obj.getSize());
+Set&
+Set::operator=(const Set& obj)
+{
+    if (this != &obj) {
+        // resize this item
+        setSize(obj.getSize());
 
-    // copy the elements from obj to this
-    for(int i=0; i<m_nArrayLen; i++) {
-      m_p_nArray[i] = obj.m_p_nArray[i];
+        // copy the elements from obj to this
+        for (int i = 0; i < m_nArrayLen; i++)
+            m_p_nArray[i] = obj.m_p_nArray[i];
     }
-  }
 
-  return *this;
+    return *this;
 }
 
-void Set::print(std::ostream& out) const
+void
+Set::print(std::ostream& out) const
 {
-  if(m_p_nArray==NULL) {
-    out << "[Set {Empty}]";
-    return;
-  }
-  char buff[24];
-  out << "[Set (" << m_nSize << ") 0x ";
-  for (int i=m_nArrayLen-1; 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 <iostream>
+#include <limits>
 
 #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
+
+    // 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
 
-class Set {
-public:
-  // Constructors
-  // creates and empty set
-  Set();
-  Set (int size);
+    long *m_p_nArray;      // an word array to hold the bits in the set
+    long m_p_nArray_Static[NUMBER_WORDS_PER_SET];
 
-  // used during the replay mechanism
-  //  Set(const char *str);
+    static const int LONG_BITS = std::numeric_limits<long>::digits;
+    static const int INDEX_SHIFT = LONG_BITS == 64 ? 6 : 5;
+    static const int INDEX_MASK = (1 << INDEX_SHIFT) - 1;
 
-  Set(const Set& obj);
-  Set& operator=(const Set& obj);
+    void clearExcess();
 
-  // Destructor
-  ~Set();
+  public:
+    Set();
+    Set(int size);
+    Set(const Set& obj);
+    ~Set();
 
-  // Public Methods
+    Set& operator=(const Set& obj);
 
-  inline void add(NodeID index)
+    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<m_nArrayLen; i++) m_p_nArray[i] = 0; }
+    void
+    clear()
+    {
+        for (int i = 0; i < m_nArrayLen; i++)
+            m_p_nArray[i] = 0;
+    }
 
-  void broadcast();
-  int count() const;
-  bool isEqual(const Set& set) const;
+    void broadcast();
+    int count() const;
+    bool isEqual(const Set& set) const;
 
-  Set OR(const Set& orSet) const;  // return the logical OR of this set and orSet
-  Set AND(const Set& andSet) const;  // return the logical AND of this set and andSet
+    // return the logical OR of this set and orSet
+    Set OR(const Set& orSet) const;
 
-  // Returns true if the intersection of the two sets is non-empty
-  inline bool intersectionIsNotEmpty(const Set& other_set) const
-    {
-      for(int i=0; i< m_nArrayLen; i++) {
-        if(m_p_nArray[i] & other_set.m_p_nArray[i]) {
-          return true;
-        }
-      }
-      return false;
-    }
+    // return the logical AND of this set and andSet
+    Set AND(const Set& andSet) const;
 
-  // Returns true if the intersection of the two sets is empty
-  inline bool intersectionIsEmpty(const Set& other_set) const
+    // Returns true if the intersection of the two sets is empty
+    bool
+    intersectionIsEmpty(const Set& other_set) const
     {
-      for(int i=0; i< m_nArrayLen; i++) {
-        if(m_p_nArray[i] & other_set.m_p_nArray[i]) {
-          return false;
-        }
-      }
-      return true;
+        for (int i = 0; i < m_nArrayLen; i++)
+            if (m_p_nArray[i] & other_set.m_p_nArray[i])
+                return false;
+        return true;
     }
 
-  bool isSuperset(const Set& test) const;
-  bool isSubset(const Set& test) const { return test.isSuperset(*this); }
+    bool isSuperset(const Set& test) const;
+    bool isSubset(const Set& test) const { return test.isSuperset(*this); }
 
-  inline bool isElement(NodeID element) const
+    bool
+    isElement(NodeID element) const
     {
-#ifdef __32BITS__
-      return ((m_p_nArray[element>>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; }
-
-  // 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
+    int getSize() const { return m_nSize; }
 
-  // Data Members (m_ prefix)
-  // gibson 05/20/05
-  // Vector<uint8> 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__