ruby: style pass

17 files changed, 1424 insertions, 2295 deletions

diff --git a/src/mem/ruby/filters/AbstractBloomFilter.hh b/src/mem/ruby/filters/AbstractBloomFilter.hh
index 89aeb25a6..de11b4499 100644
--- a/src/mem/ruby/filters/AbstractBloomFilter.hh
+++ b/src/mem/ruby/filters/AbstractBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,44 +26,32 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * AbstractBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef ABSTRACT_BLOOM_FILTER_H
-#define ABSTRACT_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__
 
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 
-class AbstractBloomFilter {
-public:
-
-  virtual ~AbstractBloomFilter() {};
-  virtual void clear() = 0;
-  virtual void increment(const Address& addr) = 0;
-  virtual void decrement(const Address& addr) = 0;
-  virtual void merge(AbstractBloomFilter * other_filter) = 0;
-  virtual void set(const Address& addr) = 0;
-  virtual void unset(const Address& addr) = 0;
-
-  virtual bool isSet(const Address& addr) = 0;
-  virtual int getCount(const Address& addr) = 0;
-  virtual int getTotalCount() = 0;
-
-  virtual void print(ostream& out) const = 0;
-
-  virtual int getIndex(const Address& addr) = 0;
-  virtual int readBit(const int index) = 0;
-  virtual void writeBit(const int index, const int value) = 0;
-
-private:
-
+class AbstractBloomFilter
+{
+  public:
+    virtual ~AbstractBloomFilter() {};
+    virtual void clear() = 0;
+    virtual void increment(const Address& addr) = 0;
+    virtual void decrement(const Address& addr) = 0;
+    virtual void merge(AbstractBloomFilter * other_filter) = 0;
+    virtual void set(const Address& addr) = 0;
+    virtual void unset(const Address& addr) = 0;
+
+    virtual bool isSet(const Address& addr) = 0;
+    virtual int getCount(const Address& addr) = 0;
+    virtual int getTotalCount() = 0;
+
+    virtual void print(ostream& out) const = 0;
+
+    virtual int getIndex(const Address& addr) = 0;
+    virtual int readBit(const int index) = 0;
+    virtual void writeBit(const int index, const int value) = 0;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/BlockBloomFilter.cc b/src/mem/ruby/filters/BlockBloomFilter.cc
index 9bf5b41c5..74b14593e 100644
--- a/src/mem/ruby/filters/BlockBloomFilter.cc
+++ b/src/mem/ruby/filters/BlockBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,121 +26,133 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * BlockBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/BlockBloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/BlockBloomFilter.hh"
 
 BlockBloomFilter::BlockBloomFilter(string str)
 {
-  string tail(str);
-  string head = string_split(tail, '_');
+    string tail(str);
+    string head = string_split(tail, '_');
 
-  m_filter_size = atoi(head.c_str());
-  m_filter_size_bits = log_int(m_filter_size);
+    m_filter_size = atoi(head.c_str());
+    m_filter_size_bits = log_int(m_filter_size);
 
-  m_filter.setSize(m_filter_size);
+    m_filter.setSize(m_filter_size);
 
-  clear();
+    clear();
 }
 
-BlockBloomFilter::~BlockBloomFilter(){
+BlockBloomFilter::~BlockBloomFilter()
+{
 }
 
-void BlockBloomFilter::clear()
+void
+BlockBloomFilter::clear()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
 }
 
-void BlockBloomFilter::increment(const Address& addr)
+void
+BlockBloomFilter::increment(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-
-void BlockBloomFilter::decrement(const Address& addr)
+void
+BlockBloomFilter::decrement(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-void BlockBloomFilter::merge(AbstractBloomFilter * other_filter)
+void
+BlockBloomFilter::merge(AbstractBloomFilter * other_filter)
 {
-  // TODO
+    // TODO
 }
 
-void BlockBloomFilter::set(const Address& addr)
+void
+BlockBloomFilter::set(const Address& addr)
 {
-  int i = get_index(addr);
-  m_filter[i] = 1;
+    int i = get_index(addr);
+    m_filter[i] = 1;
 }
 
-void BlockBloomFilter::unset(const Address& addr)
+void
+BlockBloomFilter::unset(const Address& addr)
 {
-  int i = get_index(addr);
-  m_filter[i] = 0;
+    int i = get_index(addr);
+    m_filter[i] = 0;
 }
 
-bool BlockBloomFilter::isSet(const Address& addr)
+bool
+BlockBloomFilter::isSet(const Address& addr)
 {
-  int i = get_index(addr);
-  return (m_filter[i]);
+    int i = get_index(addr);
+    return (m_filter[i]);
 }
 
-
-int BlockBloomFilter::getCount(const Address& addr)
+int
+BlockBloomFilter::getCount(const Address& addr)
 {
-  return m_filter[get_index(addr)];
+    return m_filter[get_index(addr)];
 }
 
-int BlockBloomFilter::getTotalCount()
+int
+BlockBloomFilter::getTotalCount()
 {
-  int count = 0;
+    int count = 0;
 
-  for (int i = 0; i < m_filter_size; i++) {
-    if (m_filter[i]) {
-      count++;
+    for (int i = 0; i < m_filter_size; i++) {
+        if (m_filter[i]) {
+            count++;
+        }
     }
-  }
-  return count;
+    return count;
 }
 
-int BlockBloomFilter::getIndex(const Address& addr)
+int
+BlockBloomFilter::getIndex(const Address& addr)
 {
-  return get_index(addr);
+    return get_index(addr);
 }
 
-void BlockBloomFilter::print(ostream& out) const
+void
+BlockBloomFilter::print(ostream& out) const
 {
 }
 
-int BlockBloomFilter::readBit(const int index) {
-  return m_filter[index];
+int
+BlockBloomFilter::readBit(const int index)
+{
+    return m_filter[index];
 }
 
-void BlockBloomFilter::writeBit(const int index, const int value) {
-  m_filter[index] = value;
+void
+BlockBloomFilter::writeBit(const int index, const int value)
+{
+    m_filter[index] = value;
 }
 
-int BlockBloomFilter::get_index(const Address& addr)
+int
+BlockBloomFilter::get_index(const Address& addr)
 {
-  // Pull out some bit field ==> B1
-  // Pull out additional bits, not the same as B1 ==> B2
-  //  XOR B1 and B2 to get hash index
-  physical_address_t block_bits = addr.bitSelect( RubySystem::getBlockSizeBits(), 2*RubySystem::getBlockSizeBits() - 1);
-  int offset = 5;
-  physical_address_t other_bits = addr.bitSelect( 2*RubySystem::getBlockSizeBits() + offset, 2*RubySystem::getBlockSizeBits() + offset + m_filter_size_bits - 1);
-  int index = block_bits ^ other_bits;
-  assert(index < m_filter_size);
-  return index;
+    // Pull out some bit field ==> B1
+    // Pull out additional bits, not the same as B1 ==> B2
+    //  XOR B1 and B2 to get hash index
+    physical_address_t block_bits =
+        addr.bitSelect(RubySystem::getBlockSizeBits(),
+                       2 * RubySystem::getBlockSizeBits() - 1);
+    int offset = 5;
+    physical_address_t other_bits =
+        addr.bitSelect(2 * RubySystem::getBlockSizeBits() + offset,
+                       2 * RubySystem::getBlockSizeBits() + offset +
+                       m_filter_size_bits - 1);
+    int index = block_bits ^ other_bits;
+    assert(index < m_filter_size);
+    return index;
 }
 
 
diff --git a/src/mem/ruby/filters/BlockBloomFilter.hh b/src/mem/ruby/filters/BlockBloomFilter.hh
index be9faa443..14f064975 100644
--- a/src/mem/ruby/filters/BlockBloomFilter.hh
+++ b/src/mem/ruby/filters/BlockBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,55 +26,45 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * BlockBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef BLOCK_BLOOM_FILTER_H
-#define BLOCK_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
-class BlockBloomFilter : public AbstractBloomFilter {
-public:
+class BlockBloomFilter : public AbstractBloomFilter
+{
+  public:
+    BlockBloomFilter(string config);
+    ~BlockBloomFilter();
 
-  ~BlockBloomFilter();
-  BlockBloomFilter(string config);
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
 
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
 
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
+    void print(ostream& out) const;
 
-  void print(ostream& out) const;
+  private:
+    int get_index(const Address& addr);
 
-private:
+    Vector<int> m_filter;
+    int m_filter_size;
+    int m_filter_size_bits;
 
-  int get_index(const Address& addr);
-
-  Vector<int> m_filter;
-  int m_filter_size;
-  int m_filter_size_bits;
-
-  int m_count_bits;
-  int m_count;
+    int m_count_bits;
+    int m_count;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/BulkBloomFilter.cc b/src/mem/ruby/filters/BulkBloomFilter.cc
index 264b4201c..1788c0391 100644
--- a/src/mem/ruby/filters/BulkBloomFilter.cc
+++ b/src/mem/ruby/filters/BulkBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,206 +26,220 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * BulkBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/BulkBloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/BulkBloomFilter.hh"
 
 BulkBloomFilter::BulkBloomFilter(string str)
 {
-  string tail(str);
-  string head = string_split(tail, '_');
+    string tail(str);
+    string head = string_split(tail, '_');
 
-  m_filter_size = atoi(head.c_str());
-  m_filter_size_bits = log_int(m_filter_size);
-  // split the filter bits in half, c0 and c1
-  m_sector_bits = m_filter_size_bits - 1;
+    m_filter_size = atoi(head.c_str());
+    m_filter_size_bits = log_int(m_filter_size);
+    // split the filter bits in half, c0 and c1
+    m_sector_bits = m_filter_size_bits - 1;
 
-  m_temp_filter.setSize(m_filter_size);
-  m_filter.setSize(m_filter_size);
-  clear();
-
-  // clear temp filter
-  for(int i=0; i < m_filter_size; ++i){
-    m_temp_filter[i] = 0;
-  }
-}
-
-BulkBloomFilter::~BulkBloomFilter(){
+    m_temp_filter.setSize(m_filter_size);
+    m_filter.setSize(m_filter_size);
+    clear();
 
+    // clear temp filter
+    for (int i = 0; i < m_filter_size; ++i) {
+        m_temp_filter[i] = 0;
+    }
 }
 
-void BulkBloomFilter::clear()
+BulkBloomFilter::~BulkBloomFilter()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
 }
 
-void BulkBloomFilter::increment(const Address& addr)
+void
+BulkBloomFilter::clear()
 {
-  // Not used
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
 }
 
-
-void BulkBloomFilter::decrement(const Address& addr)
+void
+BulkBloomFilter::increment(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-void BulkBloomFilter::merge(AbstractBloomFilter * other_filter)
+void
+BulkBloomFilter::decrement(const Address& addr)
 {
-  // TODO
+    // Not used
 }
 
-void BulkBloomFilter::set(const Address& addr)
+void
+BulkBloomFilter::merge(AbstractBloomFilter * other_filter)
 {
-  // c0 contains the cache index bits
-  int set_bits = m_sector_bits;
-  int block_bits = RubySystem::getBlockSizeBits();
-  int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1);
-  // c1 contains the lower m_sector_bits permuted bits
-  //Address permuted_bits = permute(addr);
-  //int c1 = permuted_bits.bitSelect(0, set_bits-1);
-  int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
-  //ASSERT(c0 < (m_filter_size/2));
-  //ASSERT(c0 + (m_filter_size/2) < m_filter_size);
-  //ASSERT(c1 < (m_filter_size/2));
-  // set v0 bit
-  m_filter[c0 + (m_filter_size/2)] = 1;
-  // set v1 bit
-  m_filter[c1] = 1;
+    // TODO
 }
 
-void BulkBloomFilter::unset(const Address& addr)
+void
+BulkBloomFilter::set(const Address& addr)
+{
+    // c0 contains the cache index bits
+    int set_bits = m_sector_bits;
+    int block_bits = RubySystem::getBlockSizeBits();
+    int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1);
+    // c1 contains the lower m_sector_bits permuted bits
+    //Address permuted_bits = permute(addr);
+    //int c1 = permuted_bits.bitSelect(0, set_bits-1);
+    int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
+    //ASSERT(c0 < (m_filter_size/2));
+    //ASSERT(c0 + (m_filter_size/2) < m_filter_size);
+    //ASSERT(c1 < (m_filter_size/2));
+    // set v0 bit
+    m_filter[c0 + (m_filter_size/2)] = 1;
+    // set v1 bit
+    m_filter[c1] = 1;
+}
+
+void
+BulkBloomFilter::unset(const Address& addr)
 {
-  // not used
+    // not used
 }
 
-bool BulkBloomFilter::isSet(const Address& addr)
+bool
+BulkBloomFilter::isSet(const Address& addr)
 {
-  // c0 contains the cache index bits
-  int set_bits = m_sector_bits;
-  int block_bits = RubySystem::getBlockSizeBits();
-  int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1);
-  // c1 contains the lower 10 permuted bits
-  //Address permuted_bits = permute(addr);
-  //int c1 = permuted_bits.bitSelect(0, set_bits-1);
-  int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
-  //ASSERT(c0 < (m_filter_size/2));
-  //ASSERT(c0 + (m_filter_size/2) < m_filter_size);
-  //ASSERT(c1 < (m_filter_size/2));
-  // set v0 bit
-  m_temp_filter[c0 + (m_filter_size/2)] = 1;
-  // set v1 bit
-  m_temp_filter[c1] = 1;
+    // c0 contains the cache index bits
+    int set_bits = m_sector_bits;
+    int block_bits = RubySystem::getBlockSizeBits();
+    int c0 = addr.bitSelect( block_bits, block_bits + set_bits - 1);
+    // c1 contains the lower 10 permuted bits
+    //Address permuted_bits = permute(addr);
+    //int c1 = permuted_bits.bitSelect(0, set_bits-1);
+    int c1 = addr.bitSelect( block_bits+set_bits, (block_bits+2*set_bits) - 1);
+    //ASSERT(c0 < (m_filter_size/2));
+    //ASSERT(c0 + (m_filter_size/2) < m_filter_size);
+    //ASSERT(c1 < (m_filter_size/2));
+    // set v0 bit
+    m_temp_filter[c0 + (m_filter_size/2)] = 1;
+    // set v1 bit
+    m_temp_filter[c1] = 1;
+
+    // perform filter intersection. If any c part is 0, no possibility
+    // of address being in signature.  get first c intersection part
+    bool zero = false;
+    for (int i = 0; i < m_filter_size/2; ++i){
+        // get intersection of signatures
+        m_temp_filter[i] = m_temp_filter[i] && m_filter[i];
+        zero = zero || m_temp_filter[i];
+    }
+    zero = !zero;
+    if (zero) {
+        // one section is zero, no possiblility of address in signature
+        // reset bits we just set
+        m_temp_filter[c0 + (m_filter_size / 2)] = 0;
+        m_temp_filter[c1] = 0;
+        return false;
+    }
 
-  // perform filter intersection. If any c part is 0, no possibility of address being in signature.
-  // get first c intersection part
-  bool zero = false;
-  for(int i=0; i < m_filter_size/2; ++i){
-    // get intersection of signatures
-    m_temp_filter[i] = m_temp_filter[i] && m_filter[i];
-    zero = zero || m_temp_filter[i];
-  }
-  zero = !zero;
-  if(zero){
-    // one section is zero, no possiblility of address in signature
-    // reset bits we just set
-    m_temp_filter[c0 + (m_filter_size/2)] = 0;
-    m_temp_filter[c1] = 0;
-    return false;
-  }
-
-  // check second section
-  zero = false;
-  for(int i=m_filter_size/2; i < m_filter_size; ++i){
-    // get intersection of signatures
-    m_temp_filter[i] =  m_temp_filter[i] && m_filter[i];
-    zero = zero || m_temp_filter[i];
-  }
-  zero = !zero;
-  if(zero){
-    // one section is zero, no possiblility of address in signature
-    m_temp_filter[c0 + (m_filter_size/2)] = 0;
+    // check second section
+    zero = false;
+    for(int i = m_filter_size / 2; i < m_filter_size; ++i) {
+        // get intersection of signatures
+        m_temp_filter[i] =  m_temp_filter[i] && m_filter[i];
+        zero = zero || m_temp_filter[i];
+    }
+    zero = !zero;
+    if (zero) {
+        // one section is zero, no possiblility of address in signature
+        m_temp_filter[c0 + (m_filter_size / 2)] = 0;
+        m_temp_filter[c1] = 0;
+        return false;
+    }
+    // one section has at least one bit set
+    m_temp_filter[c0 + (m_filter_size / 2)] = 0;
     m_temp_filter[c1] = 0;
-    return false;
-  }
-  // one section has at least one bit set
-  m_temp_filter[c0 + (m_filter_size/2)] = 0;
-  m_temp_filter[c1] = 0;
-  return true;
+    return true;
 }
 
-
-int BulkBloomFilter::getCount(const Address& addr)
+int
+BulkBloomFilter::getCount(const Address& addr)
 {
-  // not used
-  return 0;
+    // not used
+    return 0;
 }
 
-int BulkBloomFilter::getTotalCount()
+int
+BulkBloomFilter::getTotalCount()
 {
-  int count = 0;
-  for (int i = 0; i < m_filter_size; i++) {
-    if (m_filter[i]) {
-      count++;
+    int count = 0;
+    for (int i = 0; i < m_filter_size; i++) {
+        if (m_filter[i]) {
+            count++;
+        }
     }
-  }
-  return count;
+    return count;
 }
 
-int BulkBloomFilter::getIndex(const Address& addr)
+int
+BulkBloomFilter::getIndex(const Address& addr)
 {
-  return get_index(addr);
+    return get_index(addr);
 }
 
-int BulkBloomFilter::readBit(const int index) {
-  return 0;
-  // TODO
+int
+BulkBloomFilter::readBit(const int index)
+{
+    return 0;
+    // TODO
 }
 
-void BulkBloomFilter::writeBit(const int index, const int value) {
-  // TODO
+void
+BulkBloomFilter::writeBit(const int index, const int value)
+{
+    // TODO
 }
 
-void BulkBloomFilter::print(ostream& out) const
+void
+BulkBloomFilter::print(ostream& out) const
 {
 }
 
-int BulkBloomFilter::get_index(const Address& addr)
+int
+BulkBloomFilter::get_index(const Address& addr)
 {
-  return addr.bitSelect( RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_filter_size_bits - 1);
+    return addr.bitSelect(RubySystem::getBlockSizeBits(),
+                          RubySystem::getBlockSizeBits() +
+                          m_filter_size_bits - 1);
 }
 
-Address BulkBloomFilter::permute(const Address & addr){
-  // permutes the original address bits according to Table 5
-  int block_offset = RubySystem::getBlockSizeBits();
-  physical_address_t part1 = addr.bitSelect( block_offset, block_offset + 6 );
-  physical_address_t part2 = addr.bitSelect( block_offset + 9, block_offset + 9 );
-  physical_address_t part3 = addr.bitSelect( block_offset + 11, block_offset + 11 );
-  physical_address_t part4 = addr.bitSelect( block_offset + 17, block_offset + 17 );
-  physical_address_t part5 = addr.bitSelect( block_offset + 7, block_offset + 8 );
-  physical_address_t part6 = addr.bitSelect( block_offset + 10, block_offset + 10 );
-  physical_address_t part7 = addr.bitSelect( block_offset + 12, block_offset + 12 );
-  physical_address_t part8 = addr.bitSelect( block_offset + 13, block_offset + 13 );
-  physical_address_t part9 = addr.bitSelect( block_offset + 15, block_offset + 16 );
-  physical_address_t part10 = addr.bitSelect( block_offset + 18, block_offset + 20 );
-  physical_address_t part11 = addr.bitSelect( block_offset + 14, block_offset + 14 );
-
-  physical_address_t result = (part1 << 14 ) | (part2 << 13 ) | (part3 << 12 ) | (part4 << 11 ) | (part5 << 9) | (part6 << 8)
-    | (part7 << 7) | (part8 << 6) | (part9 << 4) | (part10 << 1) | (part11);
-  // assume 32 bit addresses (both virtual and physical)
-  // select the remaining high-order 11 bits
-  physical_address_t remaining_bits = (addr.bitSelect( block_offset + 21, 31 )) << 21;
-  result = result | remaining_bits;
-
-  return Address(result);
+Address
+BulkBloomFilter::permute(const Address & addr)
+{
+    // permutes the original address bits according to Table 5
+    int block_offset = RubySystem::getBlockSizeBits();
+    physical_address_t part1 = addr.bitSelect(block_offset, block_offset + 6),
+        part2 = addr.bitSelect(block_offset + 9, block_offset + 9),
+        part3 = addr.bitSelect(block_offset + 11, block_offset + 11),
+        part4 = addr.bitSelect(block_offset + 17, block_offset + 17),
+        part5 = addr.bitSelect(block_offset + 7, block_offset + 8),
+        part6 = addr.bitSelect(block_offset + 10, block_offset + 10),
+        part7 = addr.bitSelect(block_offset + 12, block_offset + 12),
+        part8 = addr.bitSelect(block_offset + 13, block_offset + 13),
+        part9 = addr.bitSelect(block_offset + 15, block_offset + 16),
+        part10 = addr.bitSelect(block_offset + 18, block_offset + 20),
+        part11 = addr.bitSelect(block_offset + 14, block_offset + 14);
+
+    physical_address_t result =
+        (part1 << 14) | (part2 << 13) | (part3 << 12) | (part4 << 11) |
+        (part5 << 9)  | (part6 << 8)  | (part7 << 7)  | (part8 << 6)  |
+        (part9 << 4)  | (part10 << 1) | (part11);
+
+    // assume 32 bit addresses (both virtual and physical)
+    // select the remaining high-order 11 bits
+    physical_address_t remaining_bits =
+        addr.bitSelect(block_offset + 21, 31) << 21;
+    result = result | remaining_bits;
+
+    return Address(result);
 }
diff --git a/src/mem/ruby/filters/BulkBloomFilter.hh b/src/mem/ruby/filters/BulkBloomFilter.hh
index 089531791..53a913dc3 100644
--- a/src/mem/ruby/filters/BulkBloomFilter.hh
+++ b/src/mem/ruby/filters/BulkBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,60 +26,50 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * BulkBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef BULK_BLOOM_FILTER_H
-#define BULK_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
-class BulkBloomFilter : public AbstractBloomFilter {
-public:
+class BulkBloomFilter : public AbstractBloomFilter
+{
+  public:
+    BulkBloomFilter(string config);
+    ~BulkBloomFilter();
 
-  ~BulkBloomFilter();
-  BulkBloomFilter(string config);
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
 
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
 
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
+    void print(ostream& out) const;
 
-  void print(ostream& out) const;
+  private:
+    int get_index(const Address& addr);
+    Address permute(const Address & addr);
 
-private:
+    Vector<int> m_filter;
+    Vector<int> m_temp_filter;
 
-  int get_index(const Address& addr);
-  Address permute(const Address & addr);
+    int m_filter_size;
+    int m_filter_size_bits;
 
-  Vector<int> m_filter;
-  Vector<int> m_temp_filter;
+    int m_sector_bits;
 
-  int m_filter_size;
-  int m_filter_size_bits;
-
-  int m_sector_bits;
-
-  int m_count_bits;
-  int m_count;
+    int m_count_bits;
+    int m_count;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/GenericBloomFilter.cc b/src/mem/ruby/filters/GenericBloomFilter.cc
index 22c75d64c..a31e97f1f 100644
--- a/src/mem/ruby/filters/GenericBloomFilter.cc
+++ b/src/mem/ruby/filters/GenericBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,123 +26,122 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * GenericBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
-
+#include "mem/ruby/common/Global.hh"
+#include "mem/ruby/filters/BlockBloomFilter.hh"
+#include "mem/ruby/filters/BulkBloomFilter.hh"
 #include "mem/ruby/filters/GenericBloomFilter.hh"
+#include "mem/ruby/filters/H3BloomFilter.hh"
 #include "mem/ruby/filters/LSB_CountingBloomFilter.hh"
-#include "mem/ruby/filters/NonCountingBloomFilter.hh"
-#include "mem/ruby/filters/BulkBloomFilter.hh"
-#include "mem/ruby/filters/BlockBloomFilter.hh"
-#include "mem/ruby/filters/MultiGrainBloomFilter.hh"
 #include "mem/ruby/filters/MultiBitSelBloomFilter.hh"
-#include "mem/ruby/filters/H3BloomFilter.hh"
+#include "mem/ruby/filters/MultiGrainBloomFilter.hh"
+#include "mem/ruby/filters/NonCountingBloomFilter.hh"
 
 GenericBloomFilter::GenericBloomFilter(string config)
 {
-  string tail(config);
-  string head = string_split(tail,'_');
-
-  if (head == "LSB_Counting" ) {
-    m_filter = new LSB_CountingBloomFilter(tail);
-  }
-  else if(head == "NonCounting" ) {
-    m_filter = new NonCountingBloomFilter(tail);
-  }
-  else if(head == "Bulk" ) {
-    m_filter = new BulkBloomFilter(tail);
-  }
-  else if(head == "Block") {
-    m_filter = new BlockBloomFilter(tail);
-  }
-  else if(head == "Multigrain"){
-    m_filter = new MultiGrainBloomFilter(tail);
-  }
-  else if(head == "MultiBitSel"){
-    m_filter = new MultiBitSelBloomFilter(tail);
-  }
-  else if(head == "H3"){
-    m_filter = new H3BloomFilter(tail);
-  }
-  else {
-    assert(0);
-  }
+    string tail(config);
+    string head = string_split(tail,'_');
+
+    if (head == "LSB_Counting" ) {
+        m_filter = new LSB_CountingBloomFilter(tail);
+    } else if(head == "NonCounting" ) {
+        m_filter = new NonCountingBloomFilter(tail);
+    } else if(head == "Bulk" ) {
+        m_filter = new BulkBloomFilter(tail);
+    } else if(head == "Block") {
+        m_filter = new BlockBloomFilter(tail);
+    } else if(head == "Multigrain"){
+        m_filter = new MultiGrainBloomFilter(tail);
+    } else if(head == "MultiBitSel"){
+        m_filter = new MultiBitSelBloomFilter(tail);
+    } else if(head == "H3"){
+        m_filter = new H3BloomFilter(tail);
+    } else {
+        assert(0);
+    }
 }
 
 GenericBloomFilter::~GenericBloomFilter()
 {
-  delete m_filter;
+    delete m_filter;
 }
 
-void GenericBloomFilter::clear()
+void
+GenericBloomFilter::clear()
 {
-  m_filter->clear();
+    m_filter->clear();
 }
 
-void GenericBloomFilter::increment(const Address& addr)
+void
+GenericBloomFilter::increment(const Address& addr)
 {
-  m_filter->increment(addr);
+    m_filter->increment(addr);
 }
 
-void GenericBloomFilter::decrement(const Address& addr)
+void
+GenericBloomFilter::decrement(const Address& addr)
 {
-  m_filter->decrement(addr);
+    m_filter->decrement(addr);
 }
 
-void GenericBloomFilter::merge(GenericBloomFilter * other_filter)
+void
+GenericBloomFilter::merge(GenericBloomFilter * other_filter)
 {
-  m_filter->merge(other_filter->getFilter());
+    m_filter->merge(other_filter->getFilter());
 }
 
-void GenericBloomFilter::set(const Address& addr)
+void
+GenericBloomFilter::set(const Address& addr)
 {
-  m_filter->set(addr);
+    m_filter->set(addr);
 }
 
-void GenericBloomFilter::unset(const Address& addr)
+void
+GenericBloomFilter::unset(const Address& addr)
 {
-  m_filter->unset(addr);
+    m_filter->unset(addr);
 }
 
-bool GenericBloomFilter::isSet(const Address& addr)
+bool
+GenericBloomFilter::isSet(const Address& addr)
 {
-  return m_filter->isSet(addr);
+    return m_filter->isSet(addr);
 }
 
-int GenericBloomFilter::getCount(const Address& addr)
+int
+GenericBloomFilter::getCount(const Address& addr)
 {
-  return m_filter->getCount(addr);
+    return m_filter->getCount(addr);
 }
 
-int GenericBloomFilter::getTotalCount()
+int
+GenericBloomFilter::getTotalCount()
 {
-  return m_filter->getTotalCount();
+    return m_filter->getTotalCount();
 }
 
-int GenericBloomFilter::getIndex(const Address& addr)
+int
+GenericBloomFilter::getIndex(const Address& addr)
 {
-  return m_filter->getIndex(addr);
+    return m_filter->getIndex(addr);
 }
 
-int GenericBloomFilter::readBit(const int index) {
-  return m_filter->readBit(index);
+int
+GenericBloomFilter::readBit(const int index)
+{
+    return m_filter->readBit(index);
 }
 
-void GenericBloomFilter::writeBit(const int index, const int value) {
-  m_filter->writeBit(index, value);
+void
+GenericBloomFilter::writeBit(const int index, const int value)
+{
+    m_filter->writeBit(index, value);
 }
 
-void GenericBloomFilter::print(ostream& out) const
+void
+GenericBloomFilter::print(ostream& out) const
 {
-  return m_filter->print(out);
+    return m_filter->print(out);
 }
 
 
diff --git a/src/mem/ruby/filters/GenericBloomFilter.hh b/src/mem/ruby/filters/GenericBloomFilter.hh
index edee22f84..b7bd56d04 100644
--- a/src/mem/ruby/filters/GenericBloomFilter.hh
+++ b/src/mem/ruby/filters/GenericBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,67 +26,54 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * GenericBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef GENERIC_BLOOM_FILTER_H
-#define GENERIC_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_GENERICBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_GENERICBLOOMFILTER_HH__
 
 #include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
-class GenericBloomFilter {
-public:
-
-  // Constructors
-  GenericBloomFilter(string config);
-
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(GenericBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
-  AbstractBloomFilter * getFilter(){
-    return m_filter;
-  }
-
-  bool isSet(const Address& addr);
-
-  int getCount(const Address& addr);
+class GenericBloomFilter
+{
+  public:
+    GenericBloomFilter(string config);
+    ~GenericBloomFilter();
 
-  int getTotalCount();
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(GenericBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
+    AbstractBloomFilter *
+    getFilter()
+    {
+        return m_filter;
+    }
 
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
+    bool isSet(const Address& addr);
 
-  void print(ostream& out) const;
-  void printConfig(ostream& out) { out << "GenericBloomFilter" << endl; }
+    int getCount(const Address& addr);
 
-  // Destructor
-  ~GenericBloomFilter();
+    int getTotalCount();
 
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
 
-private:
+    void print(ostream& out) const;
+    void printConfig(ostream& out) { out << "GenericBloomFilter" << endl; }
 
-  AbstractBloomFilter* m_filter;
+  private:
+    AbstractBloomFilter* m_filter;
 };
 
-// Output operator definition
-extern inline
-ostream& operator<<(ostream& out, const GenericBloomFilter& obj)
+inline ostream&
+operator<<(ostream& out, const GenericBloomFilter& obj)
 {
-  obj.print(out);
-  out << flush;
-  return out;
+    obj.print(out);
+    out << flush;
+    return out;
 }
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_GENERICBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/H3BloomFilter.cc b/src/mem/ruby/filters/H3BloomFilter.cc
index 6fd8ae1a0..c73a29a84 100644
--- a/src/mem/ruby/filters/H3BloomFilter.cc
+++ b/src/mem/ruby/filters/H3BloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,1338 +26,510 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * NonCountingBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/H3BloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/H3BloomFilter.hh"
 
 static int H3[64][16] = {
-{
-33268410,
-395488709,
-311024285,
-456111753,
-181495008,
-119997521,
-220697869,
-433891432,
-755927921,
-515226970,
-719448198,
-349842774,
-269183649,
-463275672,
-429800228,
-521598937
-},
-{
-628677802,
-820947732,
-809435975,
-1024657192,
-887631270,
-412050215,
-391365090,
-324227279,
-318338329,
-1038393087,
-489807930,
-387366128,
-518096428,
-324184340,
-429376066,
-447109279
-},
-{
-599747653,
-404960623,
-103933604,
-946416030,
-656460913,
-925957005,
-1047665689,
-163552053,
-88359290,
-841315415,
-899833584,
-1067336680,
-348549994,
-464045876,
-270252128,
-829897652
-},
-{
-215495230,
-966696438,
-82589012,
-750102795,
-909780866,
-920285789,
-769759214,
-331966823,
-939936006,
-439950703,
-883794828,
-1009277508,
-61634610,
-741444350,
-98689608,
-524144422
-},
-{
-93868534,
-196958667,
-774076619,
-327921978,
-122538783,
-879785030,
-690748527,
-3498564,
-83163077,
-1027963025,
-582088444,
-466152216,
-312424878,
-550064499,
-646612667,
-561099434
-},
-{
-1002047931,
-395477707,
-821317480,
-890482112,
-697094476,
-263813044,
-840275189,
-469664185,
-795625845,
-211504898,
-99204277,
-1004491153,
-725930417,
-1064479221,
-893834767,
-839719181
-},
-{
-278507126,
-985111995,
-706462983,
-1042178726,
-123281719,
-963778122,
-500881056,
-726291104,
-134293026,
-568379664,
-317050609,
-533470307,
-1022365922,
-197645211,
-315125721,
-634827678
-},
-{
-219227366,
-553960647,
-870169525,
-322232839,
-508322497,
-648672696,
-249405795,
-883596102,
-476433133,
-541372919,
-646647793,
-1042679515,
-43242483,
-600187508,
-499866821,
-135713210
-},
-{
-52837162,
-96966684,
-401840460,
-1071661176,
-733560065,
-150035417,
-341319946,
-811582750,
-636173904,
-519054065,
-196321433,
-1028294565,
-882204070,
-522965093,
-48884074,
-117810166
-},
-{
-650860353,
-789534698,
-328813544,
-473250022,
-143128306,
-173196006,
-846958825,
-174632187,
-683273509,
-405459497,
-787235556,
-773873501,
-240110267,
-426797736,
-92043842,
-711789240
-},
-{
-586637493,
-5059646,
-398035664,
-6686087,
-498300175,
-948278148,
-681227731,
-592751744,
-572019677,
-558044722,
-589368271,
-695745538,
-1073416749,
-529192035,
-550984939,
-1070620580
-},
-{
-102904663,
-647598516,
-758863940,
-313426443,
-76504114,
-1050747783,
-708436441,
-563815069,
-224107668,
-875925186,
-167675944,
-926209739,
-279737287,
-1040288182,
-768184312,
-371708956
-},
-{
-683968868,
-1027427757,
-180781926,
-742898864,
-624078545,
-645659833,
-577225838,
-987150210,
-723410002,
-224013421,
-993286634,
-33188488,
-247264323,
-888018697,
-38048664,
-189037096
-},
-{
-475612146,
-426739285,
-873726278,
-529192871,
-607715202,
-388486246,
-987001312,
-474493980,
-259747270,
-417465536,
-217062395,
-392858482,
-563810075,
-137852805,
-1051814153,
-72895217
-},
-{
-71277086,
-785496675,
-500608842,
-89633426,
-274085706,
-248467935,
-838061983,
-48106147,
-773662506,
-49545328,
-9071573,
-100739031,
-602018002,
-904371654,
-534132064,
-332211304
-},
-{
-401893602,
-735125342,
-775548339,
-210224843,
-256081130,
-482894412,
-350801633,
-1035713633,
-429458128,
-327281409,
-739927752,
-359327650,
-886942880,
-847691759,
-752417993,
-359445596
-},
-{
-267472014,
-1050659620,
-1068232362,
-1049684368,
-17130239,
-690524969,
-793224378,
-14455158,
-423092885,
-873853424,
-430535778,
-7867877,
-309731959,
-370260786,
-862353083,
-403906850
-},
-{
-993077283,
-218812656,
-389234651,
-393202875,
-413116501,
-263300295,
-470013158,
-592730725,
-441847172,
-732392823,
-407574059,
-875664777,
-271347307,
-792954404,
-554774761,
-1022424300
-},
-{
-675919719,
-637054073,
-784720745,
-149714381,
-813144874,
-502525801,
-635436670,
-1003196587,
-160786091,
-947509775,
-969788637,
-26854073,
-257964369,
-63898568,
-539767732,
-772364518
-},
-{
-943076868,
-1021732472,
-697575075,
-15843624,
-617573396,
-534113303,
-122953324,
-964873912,
-942995378,
-87830944,
-1012914818,
-455484661,
-592160054,
-599844284,
-810394353,
-836812568
-},
-{
-688992674,
-279465370,
-731582262,
-687883235,
-438178468,
-80493001,
-342701501,
-663561405,
-23360106,
-531315007,
-508931618,
-36294623,
-231216223,
-840438413,
-255665680,
-663205938
-},
-{
-857265418,
-552630887,
-8173237,
-792122963,
-210140052,
-823124938,
-667709953,
-751538219,
-991957789,
-462064153,
-19070176,
-726604748,
-714567823,
-151147895,
-1012619677,
-697114353
-},
-{
-467105652,
-683256174,
-702387467,
-28730434,
-549942998,
-48712701,
-960519696,
-1008345587,
-679267717,
-370932249,
-880419471,
-352141567,
-331640403,
-598772468,
-95160685,
-812053015
-},
-{
-1053491323,
-430526562,
-1014938507,
-109685515,
-765949103,
-177288303,
-1034642653,
-485421658,
-71850281,
-981034542,
-61620389,
-601367920,
-504420930,
-220599168,
-583051998,
-158735752
-},
-{
-103033901,
-522494916,
-658494760,
-959206022,
-931348143,
-834510661,
-21542994,
-189699884,
-679327018,
-171983002,
-96774168,
-456133168,
-543103352,
-923945936,
-970074188,
-643658485
-},
-{
-566379913,
-805798263,
-840662512,
-820206124,
-796507494,
-223712542,
-118811519,
-662246595,
-809326534,
-416471323,
-748027186,
-161169753,
-739149488,
-276330378,
-924837051,
-964873733
-},
-{
-585882743,
-135502711,
-3386031,
-625631285,
-1068193307,
-270342640,
-432739484,
-556606453,
-826419155,
-1038540977,
-158000202,
-69109538,
-207087256,
-298111218,
-678046259,
-184611498
-},
-{
-305310710,
-46237988,
-855726974,
-735975153,
-930663798,
-425764232,
-104362407,
-391371443,
-867622101,
-71645091,
-61824734,
-661902640,
-293738633,
-309416189,
-281710675,
-879317360
-},
-{
-398146324,
-398293087,
-689145387,
-1038451703,
-521637478,
-516134620,
-314658937,
-830334981,
-583400300,
-340083705,
-68029852,
-675389876,
-994635780,
-788959180,
-406967042,
-74403607
-},
-{
-69463153,
-744427484,
-191639960,
-590927798,
-969916795,
-546846769,
-728756758,
-889355646,
-520855076,
-136068426,
-776132410,
-189663815,
-252051082,
-533662856,
-362198652,
-1026161384
-},
-{
-584984279,
-1004834381,
-568439705,
-834508761,
-21812513,
-670870173,
-1052043300,
-341868768,
-473755574,
-124339439,
-36193947,
-437997647,
-137419489,
-58705193,
-337793711,
-340738909
-},
-{
-898051466,
-512792906,
-234874060,
-655358775,
-683745319,
-671676404,
-428888546,
-639928192,
-672697722,
-176477579,
-747020991,
-758211282,
-443045009,
-205395173,
-1016944273,
-5584717
-},
-{
-156038300,
-138620174,
-588466825,
-1061494056,
-1013672100,
-1064257198,
-881417791,
-839470738,
-83519030,
-100875683,
-237486447,
-461483733,
-681527127,
-777996147,
-574635362,
-815974538
-},
-{
-184168473,
-519509808,
-62531892,
-51821173,
-43787358,
-385711644,
-141325169,
-36069511,
-584183031,
-571372909,
-671503175,
-226486781,
-194932686,
-1045460970,
-753718579,
-331442433
-},
-{
-73065106,
-1015327221,
-630916840,
-1058053470,
-306737587,
-296343219,
-907194989,
-920172546,
-224516225,
-818625553,
-551143849,
-634570650,
-432966225,
-756438259,
-939564853,
-767999933
-},
-{
-884775648,
-394862257,
-446787794,
-219833788,
-727195727,
-728122304,
-249888353,
-732947974,
-289908868,
-448282580,
-618161877,
-898939716,
-739554163,
-860631799,
-1058977530,
-86916736
-},
-{
-143850006,
-352708694,
-200194048,
-979764914,
-629404175,
-546279766,
-72106714,
-860980514,
-313190585,
-897143111,
-308425797,
-953791785,
-349924906,
-221457005,
-950588925,
-908254505
-},
-{
-950032043,
-829868728,
-68623614,
-714624605,
-69760597,
-297275854,
-355894016,
-985369737,
-882852618,
-864071289,
-958512902,
-950910111,
-991368991,
-829645051,
-434698210,
-771350575
-},
-{
-552695074,
-319195551,
-80297396,
-496413831,
-944046531,
-621525571,
-617653363,
-416729825,
-441842808,
-9847464,
-99420657,
-1033914550,
-812966458,
-937053011,
-673390195,
-934577365
-},
-{
-1034695843,
-190969665,
-332900185,
-51897434,
-523888639,
-883512843,
-146908572,
-506785674,
-565814307,
-692255649,
-314052926,
-826386588,
-430691325,
-866927620,
-413880214,
-936474339
-},
-{
-129380164,
-741739952,
-1013703462,
-494392795,
-957214600,
-1010879043,
-931790677,
-94551922,
-988065869,
-120637871,
-882506912,
-395075379,
-210570485,
-812422692,
-910383687,
-817722285
-},
-{
-51850866,
-283408630,
-1053047202,
-858940389,
-818507731,
-477082181,
-353546901,
-993324368,
-407093779,
-231608253,
-1067319867,
-73159811,
-429792535,
-971320614,
-565699344,
-718823399
-},
-{
-408185106,
-491493570,
-596050720,
-310776444,
-703628192,
-454438809,
-523988035,
-728512200,
-686012353,
-976339656,
-72816924,
-116926720,
-165866591,
-452043792,
-866943072,
-968545481
-},
-{
-443231195,
-905907843,
-1061421320,
-746360489,
-1043120338,
-1069659155,
-463359031,
-688303227,
-186550710,
-155347339,
-1044842421,
-1005904570,
-69332909,
-706951903,
-422513657,
-882038450
-},
-{
-430990623,
-946501980,
-742556791,
-278398643,
-183759217,
-659404315,
-279754382,
-1069347846,
-843746517,
-222777670,
-990835599,
-548741637,
-129220580,
-1392170,
-1032654091,
-894058935
-},
-{
-452042227,
-751640705,
-259481376,
-765824585,
-145991469,
-1013683228,
-1055491225,
-536379588,
-392593350,
-913368594,
-1029429776,
-226857786,
-31505342,
-1054416381,
-32341741,
-687106649
-},
-{
-404750944,
-811417027,
-869530820,
-773491060,
-810901282,
-979340397,
-1036910290,
-461764404,
-834235095,
-765695033,
-604692390,
-452158120,
-928988098,
-442719218,
-1024059719,
-167723114
-},
-{
-974245177,
-1046377300,
-1003424287,
-787349855,
-336314155,
-875074696,
-1018462718,
-890313003,
-367376809,
-86355556,
-1020618772,
-890710345,
-444741481,
-373230261,
-767064947,
-840920177
-},
-{
-719581124,
-431808156,
-138301690,
-668222575,
-497413494,
-740492013,
-485033226,
-125301442,
-831265111,
-879071459,
-341690480,
-152975256,
-850330086,
-717444507,
-694225877,
-785340566
-},
-{
-1032766252,
-140959364,
-737474726,
-1062767538,
-364464647,
-331414723,
-356152634,
-642832379,
-158733632,
-374691640,
-285504811,
-345349905,
-876599880,
-476392727,
-479589210,
-606376325
-},
-{
-174997730,
-778177086,
-319164313,
-163614456,
-10331364,
-599358958,
-8331663,
-237538058,
-159173957,
-174533880,
-65588684,
-878222844,
-424467599,
-901803515,
-187504218,
-776690353
-},
-{
-803856182,
-965850321,
-694948067,
-218315960,
-358416571,
-683713254,
-178069303,
-428076035,
-686176454,
-579553217,
-357306738,
-315018080,
-886852373,
-568563910,
-896839725,
-257416821
-},
-{
-401650013,
-183289141,
-497957228,
-879734476,
-265024455,
-825794561,
-889237440,
-323359863,
-100258491,
-991414783,
-313986632,
-85847250,
-362520248,
-276103512,
-1041630342,
-525981595
-},
-{
-487732740,
-46201705,
-990837834,
-62744493,
-1067364756,
-58015363,
-690846283,
-680262648,
-997278956,
-469357861,
-432164624,
-996763915,
-211907847,
-167824295,
-144928194,
-454839915
-},
-{
-41404232,
-514493300,
-259546924,
-578217256,
-972345130,
-123299213,
-346040332,
-1014668104,
-520910639,
-579955198,
-36627803,
-179072921,
-547684341,
-598950511,
-269497394,
-854352266
-},
-{
-603906768,
-100863318,
-708837659,
-204175569,
-375560904,
-908375384,
-28314106,
-6303733,
-175283124,
-749851198,
-308667367,
-415293931,
-225365403,
-1032188331,
-977112710,
-819705229
-},
-{
-399767123,
-697985692,
-356790426,
-643687584,
-298624218,
-185095167,
-381653926,
-876816342,
-296720023,
-2205879,
-235816616,
-521850105,
-622753786,
-1021421218,
-726349744,
-256504902
-},
-{
-851245024,
-1022500222,
-511909628,
-313809625,
-99776025,
-39710175,
-798739932,
-741832408,
-140631966,
-898295927,
-607660421,
-870669312,
-1051422478,
-789055529,
-669113756,
-681943450
-},
-{
-853872755,
-491465269,
-503341472,
-98019440,
-258267420,
-335602837,
-320687824,
-1053324395,
-24932389,
-955011453,
-934255131,
-435625663,
-501568768,
-238967025,
-549987406,
-248619780
-},
-{
-411151284,
-576471205,
-757985419,
-544137226,
-968135693,
-877548443,
-194586894,
-74882373,
-248353663,
-21207540,
-273789651,
-853653916,
-861267970,
-533253322,
-3739570,
-661358586
-},
-{
-271430986,
-71390029,
-257643671,
-949329860,
-348156406,
-251939238,
-445808698,
-48269799,
-907589462,
-105677619,
-635451508,
-20805932,
-464874661,
-7542147,
-243619464,
-288304568
-},
-{
-368215982,
-530288964,
-770090421,
-660961164,
-614935537,
-630760399,
-931299233,
-794519275,
-779918979,
-401746493,
-561237006,
-1027202224,
-258968003,
-339508073,
-1050610516,
-1064307013
-},
-{
-1039172162,
-448331205,
-928997884,
-49813151,
-198712120,
-992335354,
-671024050,
-879525220,
-745915336,
-1038822580,
-138669665,
-917958819,
-681422342,
-792868818,
-924762727,
-816386174
-},
-{
-515190336,
-313808618,
-441296783,
-1022120897,
-792325033,
-354387581,
-59273006,
-280075434,
-411357221,
-665274694,
-4054464,
-1059046246,
-394261773,
-848616745,
-15446017,
-517723271
-}};
+    { 33268410,   395488709,  311024285,  456111753,
+      181495008,  119997521,  220697869,  433891432,
+      755927921,  515226970,  719448198,  349842774,
+      269183649,  463275672,  429800228,  521598937,  },
+
+    { 628677802,  820947732,  809435975,  1024657192,
+      887631270,  412050215,  391365090,  324227279,
+      318338329,  1038393087, 489807930,  387366128,
+      518096428,  324184340,  429376066,  447109279,  },
+
+    { 599747653,  404960623,  103933604,  946416030,
+      656460913,  925957005,  1047665689, 163552053,
+      88359290,   841315415,  899833584,  1067336680,
+      348549994,  464045876,  270252128,  829897652,  },
+
+    { 215495230,  966696438,  82589012,   750102795,
+      909780866,  920285789,  769759214,  331966823,
+      939936006,  439950703,  883794828,  1009277508,
+      61634610,   741444350,  98689608,   524144422,  },
+
+    { 93868534,   196958667,  774076619,  327921978,
+      122538783,  879785030,  690748527,  3498564,
+      83163077,   1027963025, 582088444,  466152216,
+      312424878,  550064499,  646612667,  561099434,  },
+
+    { 1002047931, 395477707,  821317480,  890482112,
+      697094476,  263813044,  840275189,  469664185,
+      795625845,  211504898,  99204277,   1004491153,
+      725930417,  1064479221, 893834767,  839719181,  },
+
+    { 278507126,  985111995,  706462983,  1042178726,
+      123281719,  963778122,  500881056,  726291104,
+      134293026,  568379664,  317050609,  533470307,
+      1022365922, 197645211,  315125721,  634827678,  },
+
+    { 219227366,  553960647,  870169525,  322232839,
+      508322497,  648672696,  249405795,  883596102,
+      476433133,  541372919,  646647793,  1042679515,
+      43242483,   600187508,  499866821,  135713210,  },
+
+    { 52837162,   96966684,   401840460,  1071661176,
+      733560065,  150035417,  341319946,  811582750,
+      636173904,  519054065,  196321433,  1028294565,
+      882204070,  522965093,  48884074,   117810166,  },
+
+    { 650860353,  789534698,  328813544,  473250022,
+      143128306,  173196006,  846958825,  174632187,
+      683273509,  405459497,  787235556,  773873501,
+      240110267,  426797736,  92043842,   711789240,  },
+
+    { 586637493,  5059646,    398035664,  6686087,
+      498300175,  948278148,  681227731,  592751744,
+      572019677,  558044722,  589368271,  695745538,
+      1073416749, 529192035,  550984939,  1070620580, },
+
+    { 102904663,  647598516,  758863940,  313426443,
+      76504114,   1050747783, 708436441,  563815069,
+      224107668,  875925186,  167675944,  926209739,
+      279737287,  1040288182, 768184312,  371708956,  },
+
+    { 683968868,  1027427757, 180781926,  742898864,
+      624078545,  645659833,  577225838,  987150210,
+      723410002,  224013421,  993286634,  33188488,
+      247264323,  888018697,  38048664,   189037096,  },
+
+    { 475612146,  426739285,  873726278,  529192871,
+      607715202,  388486246,  987001312,  474493980,
+      259747270,  417465536,  217062395,  392858482,
+      563810075,  137852805,  1051814153, 72895217,   },
+
+    { 71277086,   785496675,  500608842,  89633426,
+      274085706,  248467935,  838061983,  48106147,
+      773662506,  49545328,   9071573,    100739031,
+      602018002,  904371654,  534132064,  332211304,  },
+
+    { 401893602,  735125342,  775548339,  210224843,
+      256081130,  482894412,  350801633,  1035713633,
+      429458128,  327281409,  739927752,  359327650,
+      886942880,  847691759,  752417993,  359445596,  },
+
+    { 267472014,  1050659620, 1068232362, 1049684368,
+      17130239,   690524969,  793224378,  14455158,
+      423092885,  873853424,  430535778,  7867877,
+      309731959,  370260786,  862353083,  403906850,  },
+
+    { 993077283,  218812656,  389234651,  393202875,
+      413116501,  263300295,  470013158,  592730725,
+      441847172,  732392823,  407574059,  875664777,
+      271347307,  792954404,  554774761,  1022424300, },
+
+    { 675919719,  637054073,  784720745,  149714381,
+      813144874,  502525801,  635436670,  1003196587,
+      160786091,  947509775,  969788637,  26854073,
+      257964369,  63898568,   539767732,  772364518,  },
+
+    { 943076868,  1021732472, 697575075,  15843624,
+      617573396,  534113303,  122953324,  964873912,
+      942995378,  87830944,   1012914818, 455484661,
+      592160054,  599844284,  810394353,  836812568,  },
+
+    { 688992674,  279465370,  731582262,  687883235,
+      438178468,  80493001,   342701501,  663561405,
+      23360106,   531315007,  508931618,  36294623,
+      231216223,  840438413,  255665680,  663205938,  },
+
+    { 857265418,  552630887,  8173237,    792122963,
+      210140052,  823124938,  667709953,  751538219,
+      991957789,  462064153,  19070176,   726604748,
+      714567823,  151147895,  1012619677, 697114353,  },
+
+    { 467105652,  683256174,  702387467,  28730434,
+      549942998,  48712701,   960519696,  1008345587,
+      679267717,  370932249,  880419471,  352141567,
+      331640403,  598772468,  95160685,   812053015,  },
+
+    { 1053491323, 430526562,  1014938507, 109685515,
+      765949103,  177288303,  1034642653, 485421658,
+      71850281,   981034542,  61620389,   601367920,
+      504420930,  220599168,  583051998,  158735752,  },
+
+    { 103033901,  522494916,  658494760,  959206022,
+      931348143,  834510661,  21542994,   189699884,
+      679327018,  171983002,  96774168,   456133168,
+      543103352,  923945936,  970074188,  643658485,  },
+
+    { 566379913,  805798263,  840662512,  820206124,
+      796507494,  223712542,  118811519,  662246595,
+      809326534,  416471323,  748027186,  161169753,
+      739149488,  276330378,  924837051,  964873733,  },
+
+    { 585882743,  135502711,  3386031,    625631285,
+      1068193307, 270342640,  432739484,  556606453,
+      826419155,  1038540977, 158000202,  69109538,
+      207087256,  298111218,  678046259,  184611498,  },
+
+    { 305310710,  46237988,   855726974,  735975153,
+      930663798,  425764232,  104362407,  391371443,
+      867622101,  71645091,   61824734,   661902640,
+      293738633,  309416189,  281710675,  879317360,  },
+
+    { 398146324,  398293087,  689145387,  1038451703,
+      521637478,  516134620,  314658937,  830334981,
+      583400300,  340083705,  68029852,   675389876,
+      994635780,  788959180,  406967042,  74403607,   },
+
+    { 69463153,   744427484,  191639960,  590927798,
+      969916795,  546846769,  728756758,  889355646,
+      520855076,  136068426,  776132410,  189663815,
+      252051082,  533662856,  362198652,  1026161384, },
+
+    { 584984279,  1004834381, 568439705,  834508761,
+      21812513,   670870173,  1052043300, 341868768,
+      473755574,  124339439,  36193947,   437997647,
+      137419489,  58705193,   337793711,  340738909,  },
+
+    { 898051466,  512792906,  234874060,  655358775,
+      683745319,  671676404,  428888546,  639928192,
+      672697722,  176477579,  747020991,  758211282,
+      443045009,  205395173,  1016944273, 5584717,    },
+
+    { 156038300,  138620174,  588466825,  1061494056,
+      1013672100, 1064257198, 881417791,  839470738,
+      83519030,   100875683,  237486447,  461483733,
+      681527127,  777996147,  574635362,  815974538,  },
+
+    { 184168473,  519509808,  62531892,   51821173,
+      43787358,   385711644,  141325169,  36069511,
+      584183031,  571372909,  671503175,  226486781,
+      194932686,  1045460970, 753718579,  331442433,  },
+
+    { 73065106,   1015327221, 630916840,  1058053470,
+      306737587,  296343219,  907194989,  920172546,
+      224516225,  818625553,  551143849,  634570650,
+      432966225,  756438259,  939564853,  767999933,  },
+
+    { 884775648,  394862257,  446787794,  219833788,
+      727195727,  728122304,  249888353,  732947974,
+      289908868,  448282580,  618161877,  898939716,
+      739554163,  860631799,  1058977530, 86916736,   },
+
+    { 143850006,  352708694,  200194048,  979764914,
+      629404175,  546279766,  72106714,   860980514,
+      313190585,  897143111,  308425797,  953791785,
+      349924906,  221457005,  950588925,  908254505,  },
+
+    { 950032043,  829868728,  68623614,   714624605,
+      69760597,   297275854,  355894016,  985369737,
+      882852618,  864071289,  958512902,  950910111,
+      991368991,  829645051,  434698210,  771350575,  },
+
+    { 552695074,  319195551,  80297396,   496413831,
+      944046531,  621525571,  617653363,  416729825,
+      441842808,  9847464,    99420657,   1033914550,
+      812966458,  937053011,  673390195,  934577365,  },
+
+    { 1034695843, 190969665,  332900185,  51897434,
+      523888639,  883512843,  146908572,  506785674,
+      565814307,  692255649,  314052926,  826386588,
+      430691325,  866927620,  413880214,  936474339,  },
+
+    { 129380164,  741739952,  1013703462, 494392795,
+      957214600,  1010879043, 931790677,  94551922,
+      988065869,  120637871,  882506912,  395075379,
+      210570485,  812422692,  910383687,  817722285,  },
+
+    { 51850866,   283408630,  1053047202, 858940389,
+      818507731,  477082181,  353546901,  993324368,
+      407093779,  231608253,  1067319867, 73159811,
+      429792535,  971320614,  565699344,  718823399,  },
+
+    { 408185106,  491493570,  596050720,  310776444,
+      703628192,  454438809,  523988035,  728512200,
+      686012353,  976339656,  72816924,   116926720,
+      165866591,  452043792,  866943072,  968545481,  },
+
+    { 443231195,  905907843,  1061421320, 746360489,
+      1043120338, 1069659155, 463359031,  688303227,
+      186550710,  155347339,  1044842421, 1005904570,
+      69332909,   706951903,  422513657,  882038450,  },
+
+    { 430990623,  946501980,  742556791,  278398643,
+      183759217,  659404315,  279754382,  1069347846,
+      843746517,  222777670,  990835599,  548741637,
+      129220580,  1392170,    1032654091, 894058935,  },
+
+    { 452042227,  751640705,  259481376,  765824585,
+      145991469,  1013683228, 1055491225, 536379588,
+      392593350,  913368594,  1029429776, 226857786,
+      31505342,   1054416381, 32341741,   687106649,  },
+
+    { 404750944,  811417027,  869530820,  773491060,
+      810901282,  979340397,  1036910290, 461764404,
+      834235095,  765695033,  604692390,  452158120,
+      928988098,  442719218,  1024059719, 167723114,  },
+
+    { 974245177,  1046377300, 1003424287, 787349855,
+      336314155,  875074696,  1018462718, 890313003,
+      367376809,  86355556,   1020618772, 890710345,
+      444741481,  373230261,  767064947,  840920177,  },
+
+    { 719581124,  431808156,  138301690,  668222575,
+      497413494,  740492013,  485033226,  125301442,
+      831265111,  879071459,  341690480,  152975256,
+      850330086,  717444507,  694225877,  785340566,  },
+
+    { 1032766252, 140959364,  737474726,  1062767538,
+      364464647,  331414723,  356152634,  642832379,
+      158733632,  374691640,  285504811,  345349905,
+      876599880,  476392727,  479589210,  606376325,  },
+
+    { 174997730,  778177086,  319164313,  163614456,
+      10331364,   599358958,  8331663,    237538058,
+      159173957,  174533880,  65588684,   878222844,
+      424467599,  901803515,  187504218,  776690353,  },
+
+    { 803856182,  965850321,  694948067,  218315960,
+      358416571,  683713254,  178069303,  428076035,
+      686176454,  579553217,  357306738,  315018080,
+      886852373,  568563910,  896839725,  257416821,  },
+
+    { 401650013,  183289141,  497957228,  879734476,
+      265024455,  825794561,  889237440,  323359863,
+      100258491,  991414783,  313986632,  85847250,
+      362520248,  276103512,  1041630342, 525981595,  },
+
+    { 487732740,  46201705,   990837834,  62744493,
+      1067364756, 58015363,   690846283,  680262648,
+      997278956,  469357861,  432164624,  996763915,
+      211907847,  167824295,  144928194,  454839915,  },
+
+    { 41404232,   514493300,  259546924,  578217256,
+      972345130,  123299213,  346040332,  1014668104,
+      520910639,  579955198,  36627803,   179072921,
+      547684341,  598950511,  269497394,  854352266,  },
+
+    { 603906768,  100863318,  708837659,  204175569,
+      375560904,  908375384,  28314106,   6303733,
+      175283124,  749851198,  308667367,  415293931,
+      225365403,  1032188331, 977112710,  819705229,  },
+
+    { 399767123,  697985692,  356790426,  643687584,
+      298624218,  185095167,  381653926,  876816342,
+      296720023,  2205879,    235816616,  521850105,
+      622753786,  1021421218, 726349744,  256504902,  },
+
+    { 851245024,  1022500222, 511909628,  313809625,
+      99776025,   39710175,   798739932,  741832408,
+      140631966,  898295927,  607660421,  870669312,
+      1051422478, 789055529,  669113756,  681943450,  },
+
+    { 853872755,  491465269,  503341472,  98019440,
+      258267420,  335602837,  320687824,  1053324395,
+      24932389,   955011453,  934255131,  435625663,
+      501568768,  238967025,  549987406,  248619780,  },
+
+    { 411151284,  576471205,  757985419,  544137226,
+      968135693,  877548443,  194586894,  74882373,
+      248353663,  21207540,   273789651,  853653916,
+      861267970,  533253322,  3739570,    661358586,  },
+
+    { 271430986,  71390029,   257643671,  949329860,
+      348156406,  251939238,  445808698,  48269799,
+      907589462,  105677619,  635451508,  20805932,
+      464874661,  7542147,    243619464,  288304568,  },
+
+    { 368215982,  530288964,  770090421,  660961164,
+      614935537,  630760399,  931299233,  794519275,
+      779918979,  401746493,  561237006,  1027202224,
+      258968003,  339508073,  1050610516, 1064307013, },
+
+    { 1039172162, 448331205,  928997884,  49813151,
+      198712120,  992335354,  671024050,  879525220,
+      745915336,  1038822580, 138669665,  917958819,
+      681422342,  792868818,  924762727,  816386174,  },
+
+    { 515190336,  313808618,  441296783,  1022120897,
+      792325033,  354387581,  59273006,   280075434,
+      411357221,  665274694,  4054464,    1059046246,
+      394261773,  848616745,  15446017,   517723271,  },
+};
 
 H3BloomFilter::H3BloomFilter(string str)
 {
-  //TODO: change this ugly init code...
-  primes_list[0] = 9323;
-  primes_list[1] = 11279;
-  primes_list[2] = 10247;
-  primes_list[3] = 30637;
-  primes_list[4] = 25717;
-  primes_list[5] = 43711;
-
-  mults_list[0] = 255;
-  mults_list[1] = 29;
-  mults_list[2] = 51;
-  mults_list[3] = 3;
-  mults_list[4] = 77;
-  mults_list[5] = 43;
-
-  adds_list[0] = 841;
-  adds_list[1] = 627;
-  adds_list[2] = 1555;
-  adds_list[3] = 241;
-  adds_list[4] = 7777;
-  adds_list[5] = 65931;
-
-
-
-  string tail(str);
-  string head = string_split(tail, '_');
-
-  // head contains filter size, tail contains bit offset from block number
-  m_filter_size = atoi(head.c_str());
-
-  head = string_split(tail, '_');
-  m_num_hashes = atoi(head.c_str());
-
-  if(tail == "Regular") {
-    isParallel = false;
-  } else if (tail == "Parallel") {
-    isParallel = true;
-  } else {
-    cout << "ERROR: Incorrect config string for MultiHash Bloom! :" << str << endl;
-    assert(0);
-  }
-
-  m_filter_size_bits = log_int(m_filter_size);
-
-  m_par_filter_size = m_filter_size/m_num_hashes;
-  m_par_filter_size_bits = log_int(m_par_filter_size);
-
-  m_filter.setSize(m_filter_size);
-  clear();
+    //TODO: change this ugly init code...
+    primes_list[0] = 9323;
+    primes_list[1] = 11279;
+    primes_list[2] = 10247;
+    primes_list[3] = 30637;
+    primes_list[4] = 25717;
+    primes_list[5] = 43711;
+
+    mults_list[0] = 255;
+    mults_list[1] = 29;
+    mults_list[2] = 51;
+    mults_list[3] = 3;
+    mults_list[4] = 77;
+    mults_list[5] = 43;
+
+    adds_list[0] = 841;
+    adds_list[1] = 627;
+    adds_list[2] = 1555;
+    adds_list[3] = 241;
+    adds_list[4] = 7777;
+    adds_list[5] = 65931;
+
+    string tail(str);
+    string head = string_split(tail, '_');
+
+    // head contains filter size, tail contains bit offset from block number
+    m_filter_size = atoi(head.c_str());
+
+    head = string_split(tail, '_');
+    m_num_hashes = atoi(head.c_str());
+
+    if(tail == "Regular") {
+        isParallel = false;
+    } else if (tail == "Parallel") {
+        isParallel = true;
+    } else {
+        cout << "ERROR: Incorrect config string for MultiHash Bloom! :"
+             << str << endl;
+        assert(0);
+    }
+
+    m_filter_size_bits = log_int(m_filter_size);
+
+    m_par_filter_size = m_filter_size/m_num_hashes;
+    m_par_filter_size_bits = log_int(m_par_filter_size);
+
+    m_filter.setSize(m_filter_size);
+    clear();
 }
 
-H3BloomFilter::~H3BloomFilter(){
+H3BloomFilter::~H3BloomFilter()
+{
 }
 
-void H3BloomFilter::clear()
+void
+H3BloomFilter::clear()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
 }
 
-void H3BloomFilter::increment(const Address& addr)
+void
+H3BloomFilter::increment(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-
-void H3BloomFilter::decrement(const Address& addr)
+void
+H3BloomFilter::decrement(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-void H3BloomFilter::merge(AbstractBloomFilter * other_filter){
-  // assumes both filters are the same size!
-  H3BloomFilter * temp = (H3BloomFilter*) other_filter;
-  for(int i=0; i < m_filter_size; ++i){
-    m_filter[i] |= (*temp)[i];
-  }
-
+void
+H3BloomFilter::merge(AbstractBloomFilter *other_filter)
+{
+    // assumes both filters are the same size!
+    H3BloomFilter * temp = (H3BloomFilter*) other_filter;
+    for(int i = 0; i < m_filter_size; ++i){
+        m_filter[i] |= (*temp)[i];
+    }
 }
 
-void H3BloomFilter::set(const Address& addr)
+void
+H3BloomFilter::set(const Address& addr)
 {
-  for (int i = 0; i < m_num_hashes; i++) {
-    int idx = get_index(addr, i);
-    m_filter[idx] = 1;
-
-    //Profile hash value distribution
-    //g_system_ptr->getProfiler()->getXactProfiler()->profileHashValue(i, idx); // gem5:Arka decomissiong of log_tm
-  }
+    for (int i = 0; i < m_num_hashes; i++) {
+        int idx = get_index(addr, i);
+        m_filter[idx] = 1;
+    }
 }
 
-void H3BloomFilter::unset(const Address& addr)
+void
+H3BloomFilter::unset(const Address& addr)
 {
-  cout << "ERROR: Unset should never be called in a Bloom filter";
-  assert(0);
+    cout << "ERROR: Unset should never be called in a Bloom filter";
+    assert(0);
 }
 
-bool H3BloomFilter::isSet(const Address& addr)
+bool
+H3BloomFilter::isSet(const Address& addr)
 {
-  bool res = true;
+    bool res = true;
 
-  for (int i=0; i < m_num_hashes; i++) {
-    int idx = get_index(addr, i);
-    res = res && m_filter[idx];
-  }
-  return res;
+    for (int i = 0; i < m_num_hashes; i++) {
+        int idx = get_index(addr, i);
+        res = res && m_filter[idx];
+    }
+    return res;
 }
 
-
-int H3BloomFilter::getCount(const Address& addr)
+int
+H3BloomFilter::getCount(const Address& addr)
 {
-  return isSet(addr)? 1: 0;
+    return isSet(addr)? 1: 0;
 }
 
-int H3BloomFilter::getIndex(const Address& addr)
+int
+H3BloomFilter::getIndex(const Address& addr)
 {
-  return 0;
+    return 0;
 }
 
-int H3BloomFilter::readBit(const int index) {
-  return 0;
+int
+H3BloomFilter::readBit(const int index)
+{
+    return 0;
 }
 
-void H3BloomFilter::writeBit(const int index, const int value) {
-
+void
+H3BloomFilter::writeBit(const int index, const int value)
+{
 }
 
-int H3BloomFilter::getTotalCount()
+int
+H3BloomFilter::getTotalCount()
 {
-  int count = 0;
+    int count = 0;
 
-  for (int i = 0; i < m_filter_size; i++) {
-    count += m_filter[i];
-  }
-  return count;
+    for (int i = 0; i < m_filter_size; i++) {
+        count += m_filter[i];
+    }
+    return count;
 }
 
-void H3BloomFilter::print(ostream& out) const
+void
+H3BloomFilter::print(ostream& out) const
 {
 }
 
-int H3BloomFilter::get_index(const Address& addr, int i)
+int
+H3BloomFilter::get_index(const Address& addr, int i)
 {
-  uint64 x = addr.getLineAddress();
-  //uint64 y = (x*mults_list[i] + adds_list[i]) % primes_list[i];
-  int y = hash_H3(x,i);
-
-  if(isParallel) {
-    return (y % m_par_filter_size) + i*m_par_filter_size;
-  } else {
-    return y % m_filter_size;
-  }
+    uint64 x = addr.getLineAddress();
+    // uint64 y = (x*mults_list[i] + adds_list[i]) % primes_list[i];
+    int y = hash_H3(x,i);
+
+    if (isParallel) {
+        return (y % m_par_filter_size) + i*m_par_filter_size;
+    } else {
+        return y % m_filter_size;
+    }
 }
 
-int H3BloomFilter::hash_H3(uint64 value, int index) {
-  uint64 mask = 1;
-  uint64 val = value;
-  int result = 0;
-
-  for(int i = 0; i < 64; i++) {
-    if(val&mask) result ^= H3[i][index];
-    val = val >> 1;
-  }
-  return result;
-  }
+int
+H3BloomFilter::hash_H3(uint64 value, int index)
+{
+    uint64 mask = 1;
+    uint64 val = value;
+    int result = 0;
+
+    for (int i = 0; i < 64; i++) {
+        if(val&mask) result ^= H3[i][index];
+        val = val >> 1;
+    }
+    return result;
+}
 
diff --git a/src/mem/ruby/filters/H3BloomFilter.hh b/src/mem/ruby/filters/H3BloomFilter.hh
index 360000540..6c18508eb 100644
--- a/src/mem/ruby/filters/H3BloomFilter.hh
+++ b/src/mem/ruby/filters/H3BloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,76 +26,65 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * H3BloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef H3_BLOOM_FILTER_H
-#define H3_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
-#include "mem/ruby/system/System.hh"
-#include "mem/ruby/profiler/Profiler.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
+#include "mem/ruby/profiler/Profiler.hh"
+#include "mem/ruby/system/System.hh"
 
-class H3BloomFilter : public AbstractBloomFilter {
-public:
-
-  ~H3BloomFilter();
-  H3BloomFilter(string config);
-
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
-
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-  void print(ostream& out) const;
-
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
-
-  int operator[](const int index) const{
-    return this->m_filter[index];
-  }
+class H3BloomFilter : public AbstractBloomFilter
+{
+  public:
+    H3BloomFilter(string config);
+    ~H3BloomFilter();
 
-private:
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
 
-  int get_index(const Address& addr, int hashNumber);
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+    void print(ostream& out) const;
 
-  int hash_H3(uint64 value, int index);
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
 
-  Vector<int> m_filter;
-  int m_filter_size;
-  int m_num_hashes;
-  int m_filter_size_bits;
+    int
+    operator[](const int index) const
+    {
+        return this->m_filter[index];
+    }
 
-  int m_par_filter_size;
-  int m_par_filter_size_bits;
+  private:
+    int get_index(const Address& addr, int hashNumber);
 
-  int m_count_bits;
-  int m_count;
+    int hash_H3(uint64 value, int index);
 
+    Vector<int> m_filter;
+    int m_filter_size;
+    int m_num_hashes;
+    int m_filter_size_bits;
 
+    int m_par_filter_size;
+    int m_par_filter_size_bits;
 
-  int primes_list[6];// = {9323,11279,10247,30637,25717,43711};
-  int mults_list[6]; //= {255,29,51,3,77,43};
-  int adds_list[6]; //= {841,627,1555,241,7777,65391};
+    int m_count_bits;
+    int m_count;
 
-  bool isParallel;
+    int primes_list[6];// = {9323,11279,10247,30637,25717,43711};
+    int mults_list[6]; //= {255,29,51,3,77,43};
+    int adds_list[6]; //= {841,627,1555,241,7777,65391};
 
+    bool isParallel;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
index a79201ad4..b64c3e75a 100644
--- a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
+++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,116 +26,126 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * LSB_CountingBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/LSB_CountingBloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/LSB_CountingBloomFilter.hh"
 
 LSB_CountingBloomFilter::LSB_CountingBloomFilter(string str)
 {
-  string tail(str);
-  string head = string_split(tail, ':');
+    string tail(str);
+    string head = string_split(tail, ':');
 
-  m_filter_size = atoi(head.c_str());
-  m_filter_size_bits = log_int(m_filter_size);
+    m_filter_size = atoi(head.c_str());
+    m_filter_size_bits = log_int(m_filter_size);
 
-  m_count = atoi(tail.c_str());
-  m_count_bits = log_int(m_count);
+    m_count = atoi(tail.c_str());
+    m_count_bits = log_int(m_count);
 
-  m_filter.setSize(m_filter_size);
-  clear();
+    m_filter.setSize(m_filter_size);
+    clear();
 }
 
-LSB_CountingBloomFilter::~LSB_CountingBloomFilter(){
+LSB_CountingBloomFilter::~LSB_CountingBloomFilter()
+{
 }
 
-void LSB_CountingBloomFilter::clear()
+void
+LSB_CountingBloomFilter::clear()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
 }
 
-void LSB_CountingBloomFilter::increment(const Address& addr)
+void
+LSB_CountingBloomFilter::increment(const Address& addr)
 {
-  int i = get_index(addr);
-  if (m_filter[i] < m_count);
-    m_filter[i] += 1;
+    int i = get_index(addr);
+    if (m_filter[i] < m_count)
+        m_filter[i] += 1;
 }
 
 
-void LSB_CountingBloomFilter::decrement(const Address& addr)
+void
+LSB_CountingBloomFilter::decrement(const Address& addr)
 {
-  int i = get_index(addr);
-  if (m_filter[i] > 0)
-    m_filter[i] -= 1;
+    int i = get_index(addr);
+    if (m_filter[i] > 0)
+        m_filter[i] -= 1;
 }
 
-void LSB_CountingBloomFilter::merge(AbstractBloomFilter * other_filter)
+void
+LSB_CountingBloomFilter::merge(AbstractBloomFilter * other_filter)
 {
-  // TODO
+    // TODO
 }
 
-void LSB_CountingBloomFilter::set(const Address& addr)
+void
+LSB_CountingBloomFilter::set(const Address& addr)
 {
-  // TODO
+    // TODO
 }
 
-void LSB_CountingBloomFilter::unset(const Address& addr)
+void
+LSB_CountingBloomFilter::unset(const Address& addr)
 {
-  // TODO
+    // TODO
 }
 
-bool LSB_CountingBloomFilter::isSet(const Address& addr)
+bool
+LSB_CountingBloomFilter::isSet(const Address& addr)
 {
-  // TODO
-  return false;
+    // TODO
+    return false;
 }
 
-
-int LSB_CountingBloomFilter::getCount(const Address& addr)
+int
+LSB_CountingBloomFilter::getCount(const Address& addr)
 {
-  return m_filter[get_index(addr)];
+    return m_filter[get_index(addr)];
 }
 
-int LSB_CountingBloomFilter::getTotalCount()
+int
+LSB_CountingBloomFilter::getTotalCount()
 {
-  int count = 0;
+    int count = 0;
 
-  for (int i = 0; i < m_filter_size; i++) {
-    count += m_filter[i];
-  }
-  return count;
+    for (int i = 0; i < m_filter_size; i++) {
+        count += m_filter[i];
+    }
+    return count;
 }
 
-int LSB_CountingBloomFilter::getIndex(const Address& addr)
+int
+LSB_CountingBloomFilter::getIndex(const Address& addr)
 {
-  return get_index(addr);
+    return get_index(addr);
 }
 
-void LSB_CountingBloomFilter::print(ostream& out) const
+void
+LSB_CountingBloomFilter::print(ostream& out) const
 {
 }
 
-int LSB_CountingBloomFilter::readBit(const int index) {
-  return 0;
-  // TODO
+int
+LSB_CountingBloomFilter::readBit(const int index)
+{
+    return 0;
+    // TODO
 }
 
-void LSB_CountingBloomFilter::writeBit(const int index, const int value) {
-  // TODO
+void
+LSB_CountingBloomFilter::writeBit(const int index, const int value)
+{
+    // TODO
 }
 
-int LSB_CountingBloomFilter::get_index(const Address& addr)
+int
+LSB_CountingBloomFilter::get_index(const Address& addr)
 {
-  return addr.bitSelect( RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_filter_size_bits - 1);
+    return addr.bitSelect(RubySystem::getBlockSizeBits(),
+                          RubySystem::getBlockSizeBits() +
+                          m_filter_size_bits - 1);
 }
 
 
diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
index bfa2673fe..0d74c524a 100644
--- a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
+++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,55 +26,45 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * LSB_CountingBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef LSB_COUNTING_BLOOM_FILTER_H
-#define LSB_COUNTING_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_LSBCOUNTINGBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_LSBCOUNTINGBLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
-class LSB_CountingBloomFilter : public AbstractBloomFilter {
-public:
+class LSB_CountingBloomFilter : public AbstractBloomFilter
+{
+  public:
+    LSB_CountingBloomFilter(string config);
+    ~LSB_CountingBloomFilter();
 
-  ~LSB_CountingBloomFilter();
-  LSB_CountingBloomFilter(string config);
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
 
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
 
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
+    void print(ostream& out) const;
 
-  void print(ostream& out) const;
+  private:
+    int get_index(const Address& addr);
 
-private:
+    Vector<int> m_filter;
+    int m_filter_size;
+    int m_filter_size_bits;
 
-  int get_index(const Address& addr);
-
-  Vector<int> m_filter;
-  int m_filter_size;
-  int m_filter_size_bits;
-
-  int m_count_bits;
-  int m_count;
+    int m_count_bits;
+    int m_count;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_LSBCOUNTINGBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
index 844f80160..1fe316800 100644
--- a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
+++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,165 +26,173 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * NonCountingBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/MultiBitSelBloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/MultiBitSelBloomFilter.hh"
 
 MultiBitSelBloomFilter::MultiBitSelBloomFilter(string str)
 {
+    string tail(str);
+    string head = string_split(tail, '_');
 
-  string tail(str);
-  string head = string_split(tail, '_');
-
-  // head contains filter size, tail contains bit offset from block number
-  m_filter_size = atoi(head.c_str());
+    // head contains filter size, tail contains bit offset from block number
+    m_filter_size = atoi(head.c_str());
 
-  head = string_split(tail, '_');
-  m_num_hashes = atoi(head.c_str());
+    head = string_split(tail, '_');
+    m_num_hashes = atoi(head.c_str());
 
-  head = string_split(tail, '_');
-  m_skip_bits = atoi(head.c_str());
+    head = string_split(tail, '_');
+    m_skip_bits = atoi(head.c_str());
 
-  if(tail == "Regular") {
-    isParallel = false;
-  } else if (tail == "Parallel") {
-    isParallel = true;
-  } else {
-    cout << "ERROR: Incorrect config string for MultiBitSel Bloom! :" << str << endl;
-    assert(0);
-  }
+    if(tail == "Regular") {
+        isParallel = false;
+    } else if (tail == "Parallel") {
+        isParallel = true;
+    } else {
+        cout << "ERROR: Incorrect config string for MultiBitSel Bloom! :"
+             << str << endl;
+        assert(0);
+    }
 
-  m_filter_size_bits = log_int(m_filter_size);
+    m_filter_size_bits = log_int(m_filter_size);
 
-  m_par_filter_size = m_filter_size/m_num_hashes;
-  m_par_filter_size_bits = log_int(m_par_filter_size);
+    m_par_filter_size = m_filter_size/m_num_hashes;
+    m_par_filter_size_bits = log_int(m_par_filter_size);
 
-  m_filter.setSize(m_filter_size);
-  clear();
+    m_filter.setSize(m_filter_size);
+    clear();
 }
 
-MultiBitSelBloomFilter::~MultiBitSelBloomFilter(){
+MultiBitSelBloomFilter::~MultiBitSelBloomFilter()
+{
 }
 
-void MultiBitSelBloomFilter::clear()
+void
+MultiBitSelBloomFilter::clear()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
 }
 
-void MultiBitSelBloomFilter::increment(const Address& addr)
+void
+MultiBitSelBloomFilter::increment(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
 
-void MultiBitSelBloomFilter::decrement(const Address& addr)
+void
+MultiBitSelBloomFilter::decrement(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-void MultiBitSelBloomFilter::merge(AbstractBloomFilter * other_filter){
-  // assumes both filters are the same size!
-  MultiBitSelBloomFilter * temp = (MultiBitSelBloomFilter*) other_filter;
-  for(int i=0; i < m_filter_size; ++i){
-    m_filter[i] |= (*temp)[i];
-  }
-
+void
+MultiBitSelBloomFilter::merge(AbstractBloomFilter *other_filter)
+{
+    // assumes both filters are the same size!
+    MultiBitSelBloomFilter * temp = (MultiBitSelBloomFilter*) other_filter;
+    for(int i = 0; i < m_filter_size; ++i){
+        m_filter[i] |= (*temp)[i];
+    }
 }
 
-void MultiBitSelBloomFilter::set(const Address& addr)
+void
+MultiBitSelBloomFilter::set(const Address& addr)
 {
-  for (int i = 0; i < m_num_hashes; i++) {
-    int idx = get_index(addr, i);
-    m_filter[idx] = 1;
-
-    //Profile hash value distribution
-    //g_system_ptr->getProfiler()->getXactProfiler()->profileHashValue(i, idx); //gem5:Arka for decomissioning of log_tm
-  }
+    for (int i = 0; i < m_num_hashes; i++) {
+        int idx = get_index(addr, i);
+        m_filter[idx] = 1;
+    }
 }
 
-void MultiBitSelBloomFilter::unset(const Address& addr)
+void
+MultiBitSelBloomFilter::unset(const Address& addr)
 {
-  cout << "ERROR: Unset should never be called in a Bloom filter";
-  assert(0);
+    cout << "ERROR: Unset should never be called in a Bloom filter";
+    assert(0);
 }
 
-bool MultiBitSelBloomFilter::isSet(const Address& addr)
+bool
+MultiBitSelBloomFilter::isSet(const Address& addr)
 {
-  bool res = true;
+    bool res = true;
 
-  for (int i=0; i < m_num_hashes; i++) {
-    int idx = get_index(addr, i);
-    res = res && m_filter[idx];
-  }
-  return res;
+    for (int i=0; i < m_num_hashes; i++) {
+        int idx = get_index(addr, i);
+        res = res && m_filter[idx];
+    }
+    return res;
 }
 
-
-int MultiBitSelBloomFilter::getCount(const Address& addr)
+int
+MultiBitSelBloomFilter::getCount(const Address& addr)
 {
-  return isSet(addr)? 1: 0;
+    return isSet(addr)? 1: 0;
 }
 
-int MultiBitSelBloomFilter::getIndex(const Address& addr)
+int
+MultiBitSelBloomFilter::getIndex(const Address& addr)
 {
-  return 0;
+    return 0;
 }
 
-int MultiBitSelBloomFilter::readBit(const int index) {
-  return 0;
+int
+MultiBitSelBloomFilter::readBit(const int index)
+{
+    return 0;
 }
 
-void MultiBitSelBloomFilter::writeBit(const int index, const int value) {
-
+void
+MultiBitSelBloomFilter::writeBit(const int index, const int value)
+{
 }
 
-int MultiBitSelBloomFilter::getTotalCount()
+int
+MultiBitSelBloomFilter::getTotalCount()
 {
-  int count = 0;
+    int count = 0;
 
-  for (int i = 0; i < m_filter_size; i++) {
-    count += m_filter[i];
-  }
-  return count;
+    for (int i = 0; i < m_filter_size; i++) {
+        count += m_filter[i];
+    }
+    return count;
 }
 
-void MultiBitSelBloomFilter::print(ostream& out) const
+void
+MultiBitSelBloomFilter::print(ostream& out) const
 {
 }
 
-int MultiBitSelBloomFilter::get_index(const Address& addr, int i)
+int
+MultiBitSelBloomFilter::get_index(const Address& addr, int i)
 {
-  // m_skip_bits is used to perform BitSelect after skipping some bits. Used to simulate BitSel hashing on larger than cache-line granularities
-  uint64 x = (addr.getLineAddress()) >> m_skip_bits;
-  int y = hash_bitsel(x, i, m_num_hashes, 30, m_filter_size_bits);
-  //36-bit addresses, 6-bit cache lines
-
-  if(isParallel) {
-    return (y % m_par_filter_size) + i*m_par_filter_size;
-  } else {
-    return y % m_filter_size;
-  }
-}
-
-
-int MultiBitSelBloomFilter::hash_bitsel(uint64 value, int index, int jump, int maxBits, int numBits) {
-  uint64 mask = 1;
-  int result = 0;
-  int bit, i;
-
-  for(i = 0; i < numBits; i++) {
-    bit = (index + jump*i) % maxBits;
-    if (value & (mask << bit)) result += mask << i;
-  }
-  return result;
+    // m_skip_bits is used to perform BitSelect after skipping some
+    // bits. Used to simulate BitSel hashing on larger than cache-line
+    // granularities
+    uint64 x = (addr.getLineAddress()) >> m_skip_bits;
+    int y = hash_bitsel(x, i, m_num_hashes, 30, m_filter_size_bits);
+    //36-bit addresses, 6-bit cache lines
+
+    if (isParallel) {
+        return (y % m_par_filter_size) + i*m_par_filter_size;
+    } else {
+        return y % m_filter_size;
+    }
+}
+
+int
+MultiBitSelBloomFilter::hash_bitsel(uint64 value, int index, int jump,
+                                    int maxBits, int numBits)
+{
+    uint64 mask = 1;
+    int result = 0;
+    int bit, i;
+
+    for (i = 0; i < numBits; i++) {
+        bit = (index + jump*i) % maxBits;
+        if (value & (mask << bit)) result += mask << i;
+    }
+    return result;
 }
diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
index 360cbfdff..c3b441c20 100644
--- a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
+++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,70 +26,63 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * MultiBitSelBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef MULTIBITSEL_BLOOM_FILTER_H
-#define MULTIBITSEL_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
-#include "mem/ruby/system/System.hh"
-#include "mem/ruby/profiler/Profiler.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
+#include "mem/ruby/profiler/Profiler.hh"
+#include "mem/ruby/system/System.hh"
 
-class MultiBitSelBloomFilter : public AbstractBloomFilter {
-public:
-
-  ~MultiBitSelBloomFilter();
-  MultiBitSelBloomFilter(string config);
-
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
-
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-  void print(ostream& out) const;
-
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
-
-  int operator[](const int index) const{
-    return this->m_filter[index];
-  }
-
-private:
-
-  int get_index(const Address& addr, int hashNumber);
-
-  int hash_bitsel(uint64 value, int index, int jump, int maxBits, int numBits);
-
-  Vector<int> m_filter;
-  int m_filter_size;
-  int m_num_hashes;
-  int m_filter_size_bits;
-  int m_skip_bits;
-
-  int m_par_filter_size;
-  int m_par_filter_size_bits;
-
-  int m_count_bits;
-  int m_count;
-
-  bool isParallel;
-
+class MultiBitSelBloomFilter : public AbstractBloomFilter
+{
+  public:
+    MultiBitSelBloomFilter(string config);
+    ~MultiBitSelBloomFilter();
+
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
+
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+    void print(ostream& out) const;
+
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
+
+    int
+    operator[](const int index) const
+    {
+        return this->m_filter[index];
+    }
+
+  private:
+    int get_index(const Address& addr, int hashNumber);
+
+    int hash_bitsel(uint64 value, int index, int jump, int maxBits,
+                    int numBits);
+
+    Vector<int> m_filter;
+    int m_filter_size;
+    int m_num_hashes;
+    int m_filter_size_bits;
+    int m_skip_bits;
+
+    int m_par_filter_size;
+    int m_par_filter_size_bits;
+
+    int m_count_bits;
+    int m_count;
+
+    bool isParallel;
 };
 
-#endif
+#endif // __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.cc b/src/mem/ruby/filters/MultiGrainBloomFilter.cc
index 108168db3..543c4312a 100644
--- a/src/mem/ruby/filters/MultiGrainBloomFilter.cc
+++ b/src/mem/ruby/filters/MultiGrainBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,142 +26,156 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * MultiGrainBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/MultiGrainBloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/MultiGrainBloomFilter.hh"
 
 MultiGrainBloomFilter::MultiGrainBloomFilter(string str)
 {
-  string tail(str);
+    string tail(str);
 
-  // split into the 2 filter sizes
-  string head = string_split(tail, '_');
+    // split into the 2 filter sizes
+    string head = string_split(tail, '_');
 
-  // head contains size of 1st bloom filter, tail contains size of 2nd bloom filter
+    // head contains size of 1st bloom filter, tail contains size of
+    // 2nd bloom filter
 
-  m_filter_size = atoi(head.c_str());
-  m_filter_size_bits = log_int(m_filter_size);
+    m_filter_size = atoi(head.c_str());
+    m_filter_size_bits = log_int(m_filter_size);
 
-  m_page_filter_size = atoi(tail.c_str());
-  m_page_filter_size_bits = log_int(m_page_filter_size);
+    m_page_filter_size = atoi(tail.c_str());
+    m_page_filter_size_bits = log_int(m_page_filter_size);
 
-  m_filter.setSize(m_filter_size);
-  m_page_filter.setSize(m_page_filter_size);
-  clear();
+    m_filter.setSize(m_filter_size);
+    m_page_filter.setSize(m_page_filter_size);
+    clear();
 }
 
-MultiGrainBloomFilter::~MultiGrainBloomFilter(){
+MultiGrainBloomFilter::~MultiGrainBloomFilter()
+{
 }
 
-void MultiGrainBloomFilter::clear()
+void
+MultiGrainBloomFilter::clear()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
-  for(int i=0; i < m_page_filter_size; ++i){
-    m_page_filter[i] = 0;
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
+    for(int i=0; i < m_page_filter_size; ++i){
+        m_page_filter[i] = 0;
+    }
 }
 
-void MultiGrainBloomFilter::increment(const Address& addr)
+void
+MultiGrainBloomFilter::increment(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
 
-void MultiGrainBloomFilter::decrement(const Address& addr)
+void
+MultiGrainBloomFilter::decrement(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-void MultiGrainBloomFilter::merge(AbstractBloomFilter * other_filter)
+void
+MultiGrainBloomFilter::merge(AbstractBloomFilter *other_filter)
 {
-  // TODO
+    // TODO
 }
 
-void MultiGrainBloomFilter::set(const Address& addr)
+void
+MultiGrainBloomFilter::set(const Address& addr)
 {
-  int i = get_block_index(addr);
-  assert(i < m_filter_size);
-  assert(get_page_index(addr) < m_page_filter_size);
-  m_filter[i] = 1;
-  m_page_filter[i] = 1;
+    int i = get_block_index(addr);
+    assert(i < m_filter_size);
+    assert(get_page_index(addr) < m_page_filter_size);
+    m_filter[i] = 1;
+    m_page_filter[i] = 1;
 
 }
 
-void MultiGrainBloomFilter::unset(const Address& addr)
+void
+MultiGrainBloomFilter::unset(const Address& addr)
 {
-  // not used
+    // not used
 }
 
-bool MultiGrainBloomFilter::isSet(const Address& addr)
+bool
+MultiGrainBloomFilter::isSet(const Address& addr)
 {
-  int i = get_block_index(addr);
-  assert(i < m_filter_size);
-  assert(get_page_index(addr) < m_page_filter_size);
-  // we have to have both indices set
-  return (m_filter[i] && m_page_filter[i]);
+    int i = get_block_index(addr);
+    assert(i < m_filter_size);
+    assert(get_page_index(addr) < m_page_filter_size);
+    // we have to have both indices set
+    return (m_filter[i] && m_page_filter[i]);
 }
 
-int MultiGrainBloomFilter::getCount(const Address& addr)
+int
+MultiGrainBloomFilter::getCount(const Address& addr)
 {
-  // not used
-  return 0;
+    // not used
+    return 0;
 }
 
-int MultiGrainBloomFilter::getTotalCount()
+int
+MultiGrainBloomFilter::getTotalCount()
 {
-  int count = 0;
+    int count = 0;
 
-  for (int i = 0; i < m_filter_size; i++) {
-    count += m_filter[i];
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        count += m_filter[i];
+    }
 
-  for(int i=0; i < m_page_filter_size; ++i){
-    count += m_page_filter[i] = 0;
-  }
+    for(int i=0; i < m_page_filter_size; ++i) {
+        count += m_page_filter[i] = 0;
+    }
 
-  return count;
+    return count;
 }
 
-int MultiGrainBloomFilter::getIndex(const Address& addr)
+int
+MultiGrainBloomFilter::getIndex(const Address& addr)
 {
-  return 0;
-  // TODO
+    return 0;
+    // TODO
 }
 
-int MultiGrainBloomFilter::readBit(const int index) {
-  return 0;
-  // TODO
+int
+MultiGrainBloomFilter::readBit(const int index)
+{
+    return 0;
+    // TODO
 }
 
-void MultiGrainBloomFilter::writeBit(const int index, const int value) {
-  // TODO
+void
+MultiGrainBloomFilter::writeBit(const int index, const int value)
+{
+    // TODO
 }
 
-void MultiGrainBloomFilter::print(ostream& out) const
+void
+MultiGrainBloomFilter::print(ostream& out) const
 {
 }
 
-int MultiGrainBloomFilter::get_block_index(const Address& addr)
+int
+MultiGrainBloomFilter::get_block_index(const Address& addr)
 {
-  // grap a chunk of bits after byte offset
-  return addr.bitSelect( RubySystem::getBlockSizeBits(), RubySystem::getBlockSizeBits() + m_filter_size_bits - 1);
+    // grap a chunk of bits after byte offset
+    return addr.bitSelect(RubySystem::getBlockSizeBits(),
+                          RubySystem::getBlockSizeBits() +
+                          m_filter_size_bits - 1);
 }
 
-int MultiGrainBloomFilter::get_page_index(const Address & addr)
+int
+MultiGrainBloomFilter::get_page_index(const Address & addr)
 {
-  // grap a chunk of bits after first chunk
-  return addr.bitSelect( RubySystem::getBlockSizeBits() + m_filter_size_bits - 1,
-                         RubySystem::getBlockSizeBits() + m_filter_size_bits - 1 + m_page_filter_size_bits  - 1);
+    int bits = RubySystem::getBlockSizeBits() + m_filter_size_bits - 1;
+
+    // grap a chunk of bits after first chunk
+    return addr.bitSelect(bits, bits + m_page_filter_size_bits - 1);
 }
 
 
diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.hh b/src/mem/ruby/filters/MultiGrainBloomFilter.hh
index 4e9bc70a2..4681e2806 100644
--- a/src/mem/ruby/filters/MultiGrainBloomFilter.hh
+++ b/src/mem/ruby/filters/MultiGrainBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,61 +26,51 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * MultiGrainBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef MULTIGRAIN_BLOOM_FILTER_H
-#define MULTIGRAIN_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
-class MultiGrainBloomFilter : public AbstractBloomFilter {
-public:
+class MultiGrainBloomFilter : public AbstractBloomFilter
+{
+  public:
+    MultiGrainBloomFilter(string str);
+    ~MultiGrainBloomFilter();
 
-  ~MultiGrainBloomFilter();
-  MultiGrainBloomFilter(string str);
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
 
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
 
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
+    void print(ostream& out) const;
 
-  void print(ostream& out) const;
+  private:
+    int get_block_index(const Address& addr);
+    int get_page_index(const Address & addr);
 
-private:
+    // The block filter
+    Vector<int> m_filter;
+    int m_filter_size;
+    int m_filter_size_bits;
+    // The page number filter
+    Vector<int> m_page_filter;
+    int m_page_filter_size;
+    int m_page_filter_size_bits;
 
-  int get_block_index(const Address& addr);
-  int get_page_index(const Address & addr);
-
-  // The block filter
-  Vector<int> m_filter;
-  int m_filter_size;
-  int m_filter_size_bits;
-  // The page number filter
-  Vector<int> m_page_filter;
-  int m_page_filter_size;
-  int m_page_filter_size_bits;
-
-  int m_count_bits;
-  int m_count;
+    int m_count_bits;
+    int m_count;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.cc b/src/mem/ruby/filters/NonCountingBloomFilter.cc
index 738945105..06c069c7e 100644
--- a/src/mem/ruby/filters/NonCountingBloomFilter.cc
+++ b/src/mem/ruby/filters/NonCountingBloomFilter.cc
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,118 +26,126 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * NonCountingBloomFilter.cc
- *
- * Description:
- *
- *
- */
-
-#include "mem/ruby/filters/NonCountingBloomFilter.hh"
 #include "mem/gems_common/Map.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/filters/NonCountingBloomFilter.hh"
 
 NonCountingBloomFilter::NonCountingBloomFilter(string str)
 {
-  string tail(str);
-  string head = string_split(tail, '_');
+    string tail(str);
+    string head = string_split(tail, '_');
 
-  // head contains filter size, tail contains bit offset from block number
-  m_filter_size = atoi(head.c_str());
-  m_offset = atoi(tail.c_str());
-  m_filter_size_bits = log_int(m_filter_size);
+    // head contains filter size, tail contains bit offset from block number
+    m_filter_size = atoi(head.c_str());
+    m_offset = atoi(tail.c_str());
+    m_filter_size_bits = log_int(m_filter_size);
 
-
-  m_filter.setSize(m_filter_size);
-  clear();
+    m_filter.setSize(m_filter_size);
+    clear();
 }
 
-NonCountingBloomFilter::~NonCountingBloomFilter(){
+NonCountingBloomFilter::~NonCountingBloomFilter()
+{
 }
 
-void NonCountingBloomFilter::clear()
+void
+NonCountingBloomFilter::clear()
 {
-  for (int i = 0; i < m_filter_size; i++) {
-    m_filter[i] = 0;
-  }
+    for (int i = 0; i < m_filter_size; i++) {
+        m_filter[i] = 0;
+    }
 }
 
-void NonCountingBloomFilter::increment(const Address& addr)
+void
+NonCountingBloomFilter::increment(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-
-void NonCountingBloomFilter::decrement(const Address& addr)
+void
+NonCountingBloomFilter::decrement(const Address& addr)
 {
-  // Not used
+    // Not used
 }
 
-void NonCountingBloomFilter::merge(AbstractBloomFilter * other_filter){
-  // assumes both filters are the same size!
-  NonCountingBloomFilter * temp = (NonCountingBloomFilter*) other_filter;
-  for(int i=0; i < m_filter_size; ++i){
-    m_filter[i] |= (*temp)[i];
-  }
-
+void
+NonCountingBloomFilter::merge(AbstractBloomFilter *other_filter)
+{
+    // assumes both filters are the same size!
+    NonCountingBloomFilter * temp = (NonCountingBloomFilter*) other_filter;
+    for(int i = 0; i < m_filter_size; ++i){
+        m_filter[i] |= (*temp)[i];
+    }
 }
 
-void NonCountingBloomFilter::set(const Address& addr)
+void
+NonCountingBloomFilter::set(const Address& addr)
 {
-  int i = get_index(addr);
-  m_filter[i] = 1;
+    int i = get_index(addr);
+    m_filter[i] = 1;
 }
 
-void NonCountingBloomFilter::unset(const Address& addr)
+void
+NonCountingBloomFilter::unset(const Address& addr)
 {
-  int i = get_index(addr);
-  m_filter[i] = 0;
+    int i = get_index(addr);
+    m_filter[i] = 0;
 }
 
-bool NonCountingBloomFilter::isSet(const Address& addr)
+bool
+NonCountingBloomFilter::isSet(const Address& addr)
 {
-  int i = get_index(addr);
-  return (m_filter[i]);
+    int i = get_index(addr);
+    return (m_filter[i]);
 }
 
 
-int NonCountingBloomFilter::getCount(const Address& addr)
+int
+NonCountingBloomFilter::getCount(const Address& addr)
 {
-  return m_filter[get_index(addr)];
+    return m_filter[get_index(addr)];
 }
 
-int NonCountingBloomFilter::getTotalCount()
+int
+NonCountingBloomFilter::getTotalCount()
 {
-  int count = 0;
+    int count = 0;
 
-  for (int i = 0; i < m_filter_size; i++) {
-    count += m_filter[i];
-  }
-  return count;
+    for (int i = 0; i < m_filter_size; i++) {
+        count += m_filter[i];
+    }
+    return count;
 }
 
-void NonCountingBloomFilter::print(ostream& out) const
+void
+NonCountingBloomFilter::print(ostream& out) const
 {
 }
 
-int NonCountingBloomFilter::getIndex(const Address& addr)
+int
+NonCountingBloomFilter::getIndex(const Address& addr)
 {
-  return get_index(addr);
+    return get_index(addr);
 }
 
-int NonCountingBloomFilter::readBit(const int index) {
-  return m_filter[index];
+int
+NonCountingBloomFilter::readBit(const int index)
+{
+    return m_filter[index];
 }
 
-void NonCountingBloomFilter::writeBit(const int index, const int value) {
-  m_filter[index] = value;
+void
+NonCountingBloomFilter::writeBit(const int index, const int value)
+{
+    m_filter[index] = value;
 }
 
-int NonCountingBloomFilter::get_index(const Address& addr)
+int
+NonCountingBloomFilter::get_index(const Address& addr)
 {
-  return addr.bitSelect( RubySystem::getBlockSizeBits() + m_offset,
-                         RubySystem::getBlockSizeBits() + m_offset + m_filter_size_bits - 1);
+    return addr.bitSelect(RubySystem::getBlockSizeBits() + m_offset,
+                          RubySystem::getBlockSizeBits() + m_offset +
+                          m_filter_size_bits - 1);
 }
 
 
diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.hh b/src/mem/ruby/filters/NonCountingBloomFilter.hh
index fd23fbdf7..bec645952 100644
--- a/src/mem/ruby/filters/NonCountingBloomFilter.hh
+++ b/src/mem/ruby/filters/NonCountingBloomFilter.hh
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
  * All rights reserved.
@@ -27,61 +26,53 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * NonCountingBloomFilter.hh
- *
- * Description:
- *
- *
- */
-
-#ifndef NONCOUNTING_BLOOM_FILTER_H
-#define NONCOUNTING_BLOOM_FILTER_H
+#ifndef __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__
+#define __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__
 
 #include "mem/gems_common/Map.hh"
-#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/common/Address.hh"
+#include "mem/ruby/common/Global.hh"
 #include "mem/ruby/filters/AbstractBloomFilter.hh"
 
-class NonCountingBloomFilter : public AbstractBloomFilter {
-public:
-
-  ~NonCountingBloomFilter();
-  NonCountingBloomFilter(string config);
-
-  void clear();
-  void increment(const Address& addr);
-  void decrement(const Address& addr);
-  void merge(AbstractBloomFilter * other_filter);
-  void set(const Address& addr);
-  void unset(const Address& addr);
-
-  bool isSet(const Address& addr);
-  int getCount(const Address& addr);
-  int getTotalCount();
-
-  int getIndex(const Address& addr);
-  int readBit(const int index);
-  void writeBit(const int index, const int value);
-
-  void print(ostream& out) const;
-
-  int operator[](const int index) const{
-    return this->m_filter[index];
-  }
-
-private:
-
-  int get_index(const Address& addr);
-
-  Vector<int> m_filter;
-  int m_filter_size;
-  int m_offset;
-  int m_filter_size_bits;
-
-  int m_count_bits;
-  int m_count;
+class NonCountingBloomFilter : public AbstractBloomFilter
+{
+  public:
+    NonCountingBloomFilter(string config);
+    ~NonCountingBloomFilter();
+
+    void clear();
+    void increment(const Address& addr);
+    void decrement(const Address& addr);
+    void merge(AbstractBloomFilter * other_filter);
+    void set(const Address& addr);
+    void unset(const Address& addr);
+
+    bool isSet(const Address& addr);
+    int getCount(const Address& addr);
+    int getTotalCount();
+
+    int getIndex(const Address& addr);
+    int readBit(const int index);
+    void writeBit(const int index, const int value);
+
+    void print(ostream& out) const;
+
+    int
+    operator[](const int index) const
+    {
+        return this->m_filter[index];
+    }
+
+  private:
+    int get_index(const Address& addr);
+
+    Vector<int> m_filter;
+    int m_filter_size;
+    int m_offset;
+    int m_filter_size_bits;
+
+    int m_count_bits;
+    int m_count;
 };
 
-
-#endif
+#endif // __MEM_RUBY_FILTERS_NONCOUNTINGBLOOMFILTER_HH__