Daniel Carvalho has uploaded this change for review. (
https://gem5-review.googlesource.com/c/public/gem5/+/18874
Change subject: mem-ruby: Define BloomFilter namespace
......................................................................
mem-ruby: Define BloomFilter namespace
Define a BloomFilter namespace and put all BloomFilter related
code in it.
As a side effect the BloomFilter classes have been renamed to
remove the "BloomFilter" suffix.
Change-Id: I3ee8cc225bf3b820e561c3e25a6bf38e0012e3a8
Signed-off-by: Daniel R. Carvalho <[email protected]>
---
M src/mem/ruby/filters/AbstractBloomFilter.hh
M src/mem/ruby/filters/BlockBloomFilter.cc
M src/mem/ruby/filters/BlockBloomFilter.hh
M src/mem/ruby/filters/BloomFilters.py
M src/mem/ruby/filters/BulkBloomFilter.cc
M src/mem/ruby/filters/BulkBloomFilter.hh
M src/mem/ruby/filters/H3BloomFilter.cc
M src/mem/ruby/filters/H3BloomFilter.hh
M src/mem/ruby/filters/LSB_CountingBloomFilter.cc
M src/mem/ruby/filters/LSB_CountingBloomFilter.hh
M src/mem/ruby/filters/MultiBitSelBloomFilter.cc
M src/mem/ruby/filters/MultiBitSelBloomFilter.hh
M src/mem/ruby/filters/MultiGrainBloomFilter.cc
M src/mem/ruby/filters/MultiGrainBloomFilter.hh
14 files changed, 184 insertions(+), 127 deletions(-)
diff --git a/src/mem/ruby/filters/AbstractBloomFilter.hh
b/src/mem/ruby/filters/AbstractBloomFilter.hh
index 1c47da3..23b9aed 100644
--- a/src/mem/ruby/filters/AbstractBloomFilter.hh
+++ b/src/mem/ruby/filters/AbstractBloomFilter.hh
@@ -47,10 +47,12 @@
#include "base/intmath.hh"
#include "base/types.hh"
-#include "params/AbstractBloomFilter.hh"
+#include "params/BloomFilterBase.hh"
#include "sim/sim_object.hh"
-class AbstractBloomFilter : public SimObject
+namespace BloomFilter {
+
+class Base : public SimObject
{
protected:
/** Offset in an address due to the cache line bits. */
@@ -69,13 +71,13 @@
/**
* Create and clear the filter.
*/
- AbstractBloomFilter(const AbstractBloomFilterParams* p)
+ Base(const BloomFilterBaseParams* p)
: SimObject(p), blkBits(p->block_bits), filter(p->size),
sizeBits(floorLog2(p->size)), setThreshold(p->threshold)
{
clear();
}
- virtual ~AbstractBloomFilter() {};
+ virtual ~Base() {};
/**
* Clear the filter by resetting all values.
@@ -94,7 +96,7 @@
* @param other The other bloom filter to merge with.
*/
virtual void
- merge(const AbstractBloomFilter* other)
+ merge(const Base* other)
{
assert(filter.size() == other->filter.size());
for (int i = 0; i < filter.size(); ++i){
@@ -155,4 +157,6 @@
}
};
+} // namespace BloomFilter
+
#endif // __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/BlockBloomFilter.cc
b/src/mem/ruby/filters/BlockBloomFilter.cc
index 93557f0..432a53b 100644
--- a/src/mem/ruby/filters/BlockBloomFilter.cc
+++ b/src/mem/ruby/filters/BlockBloomFilter.cc
@@ -30,10 +30,12 @@
#include "base/bitfield.hh"
#include "base/logging.hh"
-#include "params/BlockBloomFilter.hh"
+#include "params/BloomFilterBlock.hh"
-BlockBloomFilter::BlockBloomFilter(const BlockBloomFilterParams* p)
- : AbstractBloomFilter(p),
+namespace BloomFilter {
+
+Block::Block(const BloomFilterBlockParams* p)
+ : Base(p),
offsetLSB(p->offset_lsb), numLSBBits(p->num_lsb_bits),
offsetMSB(p->offset_msb), numMSBBits(p->num_msb_bits)
{
@@ -47,30 +49,30 @@
"number of bits in an address");
}
-BlockBloomFilter::~BlockBloomFilter()
+Block::~Block()
{
}
void
-BlockBloomFilter::set(Addr addr)
+Block::set(Addr addr)
{
filter[hash(addr)] = 1;
}
void
-BlockBloomFilter::unset(Addr addr)
+Block::unset(Addr addr)
{
filter[hash(addr)] = 0;
}
int
-BlockBloomFilter::getCount(Addr addr) const
+Block::getCount(Addr addr) const
{
return filter[hash(addr)];
}
int
-BlockBloomFilter::hash(Addr addr) const
+Block::hash(Addr addr) const
{
const Addr lsb_bitfield =
bits(addr, offsetLSB + numLSBBits - 1, offsetLSB);
@@ -82,8 +84,11 @@
return index;
}
-BlockBloomFilter*
-BlockBloomFilterParams::create()
+} // namespace BloomFilter
+
+BloomFilter::Block*
+BloomFilterBlockParams::create()
{
- return new BlockBloomFilter(this);
+ return new BloomFilter::Block(this);
}
+
diff --git a/src/mem/ruby/filters/BlockBloomFilter.hh
b/src/mem/ruby/filters/BlockBloomFilter.hh
index 90cac98..4a4ee88 100644
--- a/src/mem/ruby/filters/BlockBloomFilter.hh
+++ b/src/mem/ruby/filters/BlockBloomFilter.hh
@@ -31,18 +31,20 @@
#include "mem/ruby/filters/AbstractBloomFilter.hh"
-struct BlockBloomFilterParams;
+struct BloomFilterBlockParams;
+
+namespace BloomFilter {
/**
* Simple deletable (with false negatives) bloom filter that extracts two
* bitfields of an address to use as indexes of the filter vector, ignoring
* the block offset bits.
*/
-class BlockBloomFilter : public AbstractBloomFilter
+class Block : public Base
{
public:
- BlockBloomFilter(const BlockBloomFilterParams* p);
- ~BlockBloomFilter();
+ Block(const BloomFilterBlockParams* p);
+ ~Block();
void set(Addr addr) override;
void unset(Addr addr) override;
@@ -80,4 +82,6 @@
const unsigned numMSBBits;
};
+} // namespace BloomFilter
+
#endif // __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/BloomFilters.py
b/src/mem/ruby/filters/BloomFilters.py
index 1dfcf4c..cedf1ee 100644
--- a/src/mem/ruby/filters/BloomFilters.py
+++ b/src/mem/ruby/filters/BloomFilters.py
@@ -30,10 +30,11 @@
from m5.proxy import *
from m5.SimObject import SimObject
-class AbstractBloomFilter(SimObject):
- type = 'AbstractBloomFilter'
+class BloomFilterBase(SimObject):
+ type = 'BloomFilterBase'
abstract = True
cxx_header = "mem/ruby/filters/AbstractBloomFilter.hh"
+ cxx_class = 'BloomFilter::Base'
size = Param.Int(4096, "Number of entries in the filter")
@@ -43,9 +44,9 @@
# Most of the filters are booleans, and thus saturate on 1
threshold = Param.Int(1, "Value at which an entry is considered as
set")
-class BlockBloomFilter(AbstractBloomFilter):
- type = 'BlockBloomFilter'
- cxx_class = 'BlockBloomFilter'
+class BloomFilterBlock(BloomFilterBase):
+ type = 'BloomFilterBlock'
+ cxx_class = 'BloomFilter::Block'
cxx_header = "mem/ruby/filters/BlockBloomFilter.hh"
offset_lsb = Param.Unsigned(Self.block_bits,
@@ -57,14 +58,14 @@
num_msb_bits = Param.Unsigned(Self.block_bits,
"Number of MSB bits used in the XOR hash")
-class BulkBloomFilter(AbstractBloomFilter):
- type = 'BulkBloomFilter'
- cxx_class = 'BulkBloomFilter'
+class BloomFilterBulk(BloomFilterBase):
+ type = 'BloomFilterBulk'
+ cxx_class = 'BloomFilter::Bulk'
cxx_header = "mem/ruby/filters/BulkBloomFilter.hh"
-class LSB_CountingBloomFilter(AbstractBloomFilter):
- type = 'LSB_CountingBloomFilter'
- cxx_class = 'LSB_CountingBloomFilter'
+class BloomFilterLSBCounting(BloomFilterBase):
+ type = 'BloomFilterLSBCounting'
+ cxx_class = 'BloomFilter::LSBCounting'
cxx_header = "mem/ruby/filters/LSB_CountingBloomFilter.hh"
# By default use 4-bit saturating counters
@@ -73,9 +74,9 @@
# We assume that isSet will return true only when the counter saturates
threshold = Self.max_value
-class MultiBitSelBloomFilter(AbstractBloomFilter):
- type = 'MultiBitSelBloomFilter'
- cxx_class = 'MultiBitSelBloomFilter'
+class BloomFilterMultiBitSel(BloomFilterBase):
+ type = 'BloomFilterMultiBitSel'
+ cxx_class = 'BloomFilter::MultiBitSel'
cxx_header = "mem/ruby/filters/MultiBitSelBloomFilter.hh"
num_hashes = Param.Int(4, "Number of hashes")
@@ -83,14 +84,14 @@
skip_bits = Param.Int(2, "Offset from block number")
is_parallel = Param.Bool(False, "Whether hashing is done in parallel")
-class H3BloomFilter(MultiBitSelBloomFilter):
- type = 'H3BloomFilter'
- cxx_class = 'H3BloomFilter'
+class BloomFilterH3(BloomFilterMultiBitSel):
+ type = 'BloomFilterH3'
+ cxx_class = 'BloomFilter::H3'
cxx_header = "mem/ruby/filters/H3BloomFilter.hh"
-class MultiGrainBloomFilter(AbstractBloomFilter):
- type = 'MultiGrainBloomFilter'
- cxx_class = 'MultiGrainBloomFilter'
+class BloomFilterMultiGrain(BloomFilterBase):
+ type = 'BloomFilterMultiGrain'
+ cxx_class = 'BloomFilter::MultiGrain'
cxx_header = "mem/ruby/filters/MultiGrainBloomFilter.hh"
# The base filter should not be used, since this filter is the
combination
@@ -100,9 +101,9 @@
# These should be set together. By default there are two sub-filters
that
# hash sequential bitfields
num_filters = Param.Int(2, "Number of sub-filters")
- filters = VectorParam.AbstractBloomFilter([
- BlockBloomFilter(size = 4096, offset_lsb = 6),
- BlockBloomFilter(size = 1024, offset_lsb = 18)],
+ filters = VectorParam.BloomFilterBase([
+ BloomFilterBlock(size = 4096, offset_lsb = 6),
+ BloomFilterBlock(size = 1024, offset_lsb = 18)],
"Sub-filters to be combined")
# This is the maximum value achievable of the sum of the hashed
respective
diff --git a/src/mem/ruby/filters/BulkBloomFilter.cc
b/src/mem/ruby/filters/BulkBloomFilter.cc
index 88de4c8..6824b98 100644
--- a/src/mem/ruby/filters/BulkBloomFilter.cc
+++ b/src/mem/ruby/filters/BulkBloomFilter.cc
@@ -29,19 +29,21 @@
#include "mem/ruby/filters/BulkBloomFilter.hh"
#include "base/bitfield.hh"
-#include "params/BulkBloomFilter.hh"
+#include "params/BloomFilterBulk.hh"
-BulkBloomFilter::BulkBloomFilter(const BulkBloomFilterParams* p)
- : AbstractBloomFilter(p), sectorBits(sizeBits - 1)
+namespace BloomFilter {
+
+Bulk::Bulk(const BloomFilterBulkParams* p)
+ : Base(p), sectorBits(sizeBits - 1)
{
}
-BulkBloomFilter::~BulkBloomFilter()
+Bulk::~Bulk()
{
}
void
-BulkBloomFilter::set(Addr addr)
+Bulk::set(Addr addr)
{
// c0 contains the cache index bits
int c0 = bits(addr, blkBits + sectorBits - 1, blkBits);
@@ -59,7 +61,7 @@
}
bool
-BulkBloomFilter::isSet(Addr addr) const
+Bulk::isSet(Addr addr) const
{
// c0 contains the cache index bits
const int filter_size = filter.size();
@@ -115,14 +117,14 @@
}
int
-BulkBloomFilter::getCount(Addr addr) const
+Bulk::getCount(Addr addr) const
{
// TODO as in the multi-hashed filters
return 0;
}
Addr
-BulkBloomFilter::hash(Addr addr) const
+Bulk::hash(Addr addr) const
{
// permutes the original address bits according to Table 5
Addr part1 = bits(addr, blkBits + 6, blkBits),
@@ -149,8 +151,11 @@
return result;
}
-BulkBloomFilter*
-BulkBloomFilterParams::create()
+} // namespace BloomFilter
+
+BloomFilter::Bulk*
+BloomFilterBulkParams::create()
{
- return new BulkBloomFilter(this);
+ return new BloomFilter::Bulk(this);
}
+
diff --git a/src/mem/ruby/filters/BulkBloomFilter.hh
b/src/mem/ruby/filters/BulkBloomFilter.hh
index 54c976a..8eb6edf 100644
--- a/src/mem/ruby/filters/BulkBloomFilter.hh
+++ b/src/mem/ruby/filters/BulkBloomFilter.hh
@@ -33,17 +33,19 @@
#include "mem/ruby/filters/AbstractBloomFilter.hh"
-struct BulkBloomFilterParams;
+struct BloomFilterBulkParams;
+
+namespace BloomFilter {
/**
* Implementation of the bloom filter, as described in "Bulk
Disambiguation of
* Speculative Threads in Multiprocessors", by Ceze, Luis, et al.
*/
-class BulkBloomFilter : public AbstractBloomFilter
+class Bulk : public Base
{
public:
- BulkBloomFilter(const BulkBloomFilterParams* p);
- ~BulkBloomFilter();
+ Bulk(const BloomFilterBulkParams* p);
+ ~Bulk();
void set(Addr addr) override;
@@ -58,4 +60,6 @@
const int sectorBits;
};
+} // namespace BloomFilter
+
#endif // __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/H3BloomFilter.cc
b/src/mem/ruby/filters/H3BloomFilter.cc
index dc54992..8d04f95 100644
--- a/src/mem/ruby/filters/H3BloomFilter.cc
+++ b/src/mem/ruby/filters/H3BloomFilter.cc
@@ -30,9 +30,11 @@
#include "base/logging.hh"
#include "base/bitfield.hh"
-#include "params/H3BloomFilter.hh"
+#include "params/BloomFilterH3.hh"
-static int H3[64][16] = {
+namespace BloomFilter {
+
+static int H3Matrix[64][16] = {
{ 33268410, 395488709, 311024285, 456111753,
181495008, 119997521, 220697869, 433891432,
755927921, 515226970, 719448198, 349842774,
@@ -354,25 +356,25 @@
394261773, 848616745, 15446017, 517723271, },
};
-H3BloomFilter::H3BloomFilter(const H3BloomFilterParams* p)
- : MultiBitSelBloomFilter(p)
+H3::H3(const BloomFilterH3Params* p)
+ : MultiBitSel(p)
{
fatal_if(numHashes > 16, "There are only 16 H3 functions
implemented.");
}
-H3BloomFilter::~H3BloomFilter()
+H3::~H3()
{
}
int
-H3BloomFilter::hash(Addr addr, int hash_number) const
+H3::hash(Addr addr, int hash_number) const
{
uint64_t val = bits(addr, 63, blkBits);
int result = 0;
for (int i = 0; (i < 64) && val; i++, val >>= 1) {
if (val & 1) {
- result ^= H3[i][hash_number];
+ result ^= H3Matrix[i][hash_number];
}
}
@@ -383,8 +385,11 @@
}
}
-H3BloomFilter*
-H3BloomFilterParams::create()
+} // namespace BloomFilter
+
+BloomFilter::H3*
+BloomFilterH3Params::create()
{
- return new H3BloomFilter(this);
+ return new BloomFilter::H3(this);
}
+
diff --git a/src/mem/ruby/filters/H3BloomFilter.hh
b/src/mem/ruby/filters/H3BloomFilter.hh
index 5719d00..6235c02 100644
--- a/src/mem/ruby/filters/H3BloomFilter.hh
+++ b/src/mem/ruby/filters/H3BloomFilter.hh
@@ -31,20 +31,24 @@
#include "mem/ruby/filters/MultiBitSelBloomFilter.hh"
-struct H3BloomFilterParams;
+struct BloomFilterH3Params;
+
+namespace BloomFilter {
/**
* Implementation of the bloom filter as described in "Implementing
Signatures
* for Transactional Memory", by Sanchez, Daniel, et al.
*/
-class H3BloomFilter : public MultiBitSelBloomFilter
+class H3 : public MultiBitSel
{
public:
- H3BloomFilter(const H3BloomFilterParams* p);
- ~H3BloomFilter();
+ H3(const BloomFilterH3Params* p);
+ ~H3();
protected:
int hash(Addr addr, int hash_number) const override;
};
+} // namespace BloomFilter
+
#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 3493181..30a535d 100644
--- a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
+++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc
@@ -29,22 +29,24 @@
#include "mem/ruby/filters/LSB_CountingBloomFilter.hh"
#include "base/bitfield.hh"
-#include "params/LSB_CountingBloomFilter.hh"
+#include "params/BloomFilterLSBCounting.hh"
-LSB_CountingBloomFilter::LSB_CountingBloomFilter(
- const LSB_CountingBloomFilterParams* p)
- : AbstractBloomFilter(p), maxValue(p->max_value)
+namespace BloomFilter {
+
+LSBCounting::LSBCounting(
+ const BloomFilterLSBCountingParams* p)
+ : Base(p), maxValue(p->max_value)
{
}
-LSB_CountingBloomFilter::~LSB_CountingBloomFilter()
+LSBCounting::~LSBCounting()
{
}
void
-LSB_CountingBloomFilter::merge(const AbstractBloomFilter* other)
+LSBCounting::merge(const Base* other)
{
- auto* cast_other = static_cast<const LSB_CountingBloomFilter*>(other);
+ auto* cast_other = static_cast<const LSBCounting*>(other);
assert(filter.size() == cast_other->filter.size());
for (int i = 0; i < filter.size(); ++i){
if (filter[i] < maxValue - cast_other->filter[i]) {
@@ -56,7 +58,7 @@
}
void
-LSB_CountingBloomFilter::set(Addr addr)
+LSBCounting::set(Addr addr)
{
const int i = hash(addr);
if (filter[i] < maxValue)
@@ -64,7 +66,7 @@
}
void
-LSB_CountingBloomFilter::unset(Addr addr)
+LSBCounting::unset(Addr addr)
{
const int i = hash(addr);
if (filter[i] > 0)
@@ -72,19 +74,22 @@
}
int
-LSB_CountingBloomFilter::getCount(Addr addr) const
+LSBCounting::getCount(Addr addr) const
{
return filter[hash(addr)];
}
int
-LSB_CountingBloomFilter::hash(Addr addr) const
+LSBCounting::hash(Addr addr) const
{
return bits(addr, blkBits + sizeBits - 1, blkBits);
}
-LSB_CountingBloomFilter*
-LSB_CountingBloomFilterParams::create()
+} // namespace BloomFilter
+
+BloomFilter::LSBCounting*
+BloomFilterLSBCountingParams::create()
{
- return new LSB_CountingBloomFilter(this);
+ return new BloomFilter::LSBCounting(this);
}
+
diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
index 410f22d..efc6b67 100644
--- a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
+++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh
@@ -31,15 +31,17 @@
#include "mem/ruby/filters/AbstractBloomFilter.hh"
-struct LSB_CountingBloomFilterParams;
+struct BloomFilterLSBCountingParams;
-class LSB_CountingBloomFilter : public AbstractBloomFilter
+namespace BloomFilter {
+
+class LSBCounting : public Base
{
public:
- LSB_CountingBloomFilter(const LSB_CountingBloomFilterParams* p);
- ~LSB_CountingBloomFilter();
+ LSBCounting(const BloomFilterLSBCountingParams* p);
+ ~LSBCounting();
- void merge(const AbstractBloomFilter* other) override;
+ void merge(const Base* other) override;
void set(Addr addr) override;
void unset(Addr addr) override;
@@ -52,4 +54,6 @@
const int maxValue;
};
+} // namespace BloomFilter
+
#endif //__MEM_RUBY_FILTERS_LSB_COUNTINGBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
index b822548..ecaf9f4 100644
--- a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
+++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc
@@ -29,11 +29,12 @@
#include "mem/ruby/filters/MultiBitSelBloomFilter.hh"
#include "base/bitfield.hh"
-#include "params/MultiBitSelBloomFilter.hh"
+#include "params/BloomFilterMultiBitSel.hh"
-MultiBitSelBloomFilter::MultiBitSelBloomFilter(
- const MultiBitSelBloomFilterParams* p)
- : AbstractBloomFilter(p), numHashes(p->num_hashes),
+namespace BloomFilter {
+
+MultiBitSel::MultiBitSel(const BloomFilterMultiBitSelParams* p)
+ : Base(p), numHashes(p->num_hashes),
parFilterSize(p->size / numHashes),
isParallel(p->is_parallel), skipBits(p->skip_bits)
{
@@ -43,12 +44,12 @@
}
}
-MultiBitSelBloomFilter::~MultiBitSelBloomFilter()
+MultiBitSel::~MultiBitSel()
{
}
void
-MultiBitSelBloomFilter::set(Addr addr)
+MultiBitSel::set(Addr addr)
{
for (int i = 0; i < numHashes; i++) {
int idx = hash(addr, i);
@@ -57,7 +58,7 @@
}
int
-MultiBitSelBloomFilter::getCount(Addr addr) const
+MultiBitSel::getCount(Addr addr) const
{
int count = 0;
for (int i=0; i < numHashes; i++) {
@@ -67,7 +68,7 @@
}
int
-MultiBitSelBloomFilter::hash(Addr addr, int hash_number) const
+MultiBitSel::hash(Addr addr, int hash_number) const
{
uint64_t value = bits(addr, sizeof(Addr) * 8 - 1, blkBits) >> skipBits;
const int max_bits = sizeof(Addr) * 8 - blkBits;
@@ -88,8 +89,11 @@
}
}
-MultiBitSelBloomFilter*
-MultiBitSelBloomFilterParams::create()
+} // namespace BloomFilter
+
+BloomFilter::MultiBitSel*
+BloomFilterMultiBitSelParams::create()
{
- return new MultiBitSelBloomFilter(this);
+ return new BloomFilter::MultiBitSel(this);
}
+
diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
index 34e38ca..5821335 100644
--- a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
+++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh
@@ -31,17 +31,19 @@
#include "mem/ruby/filters/AbstractBloomFilter.hh"
-struct MultiBitSelBloomFilterParams;
+struct BloomFilterMultiBitSelParams;
+
+namespace BloomFilter {
/**
* The MultiBitSel Bloom Filter associates an address to multiple entries
* through the use of multiple hash functions.
*/
-class MultiBitSelBloomFilter : public AbstractBloomFilter
+class MultiBitSel : public Base
{
public:
- MultiBitSelBloomFilter(const MultiBitSelBloomFilterParams* p);
- ~MultiBitSelBloomFilter();
+ MultiBitSel(const BloomFilterMultiBitSelParams* p);
+ ~MultiBitSel();
void set(Addr addr) override;
int getCount(Addr addr) const override;
@@ -72,4 +74,6 @@
const int skipBits;
};
+} // namespace BloomFilter
+
#endif // __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__
diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.cc
b/src/mem/ruby/filters/MultiGrainBloomFilter.cc
index e1db66e..e2f706a 100644
--- a/src/mem/ruby/filters/MultiGrainBloomFilter.cc
+++ b/src/mem/ruby/filters/MultiGrainBloomFilter.cc
@@ -29,22 +29,23 @@
#include "mem/ruby/filters/MultiGrainBloomFilter.hh"
#include "base/logging.hh"
-#include "params/MultiGrainBloomFilter.hh"
+#include "params/BloomFilterMultiGrain.hh"
-MultiGrainBloomFilter::MultiGrainBloomFilter(
- const MultiGrainBloomFilterParams* p)
- : AbstractBloomFilter(p), filters(p->filters)
+namespace BloomFilter {
+
+MultiGrain::MultiGrain(const BloomFilterMultiGrainParams* p)
+ : Base(p), filters(p->filters)
{
fatal_if(p->num_filters != filters.size(), "The number of filters " \
"should match the number of filters provided");
}
-MultiGrainBloomFilter::~MultiGrainBloomFilter()
+MultiGrain::~MultiGrain()
{
}
void
-MultiGrainBloomFilter::clear()
+MultiGrain::clear()
{
for (auto& sub_filter : filters) {
sub_filter->clear();
@@ -52,9 +53,9 @@
}
void
-MultiGrainBloomFilter::merge(const AbstractBloomFilter* other)
+MultiGrain::merge(const Base* other)
{
- auto* cast_other = static_cast<const MultiGrainBloomFilter*>(other);
+ auto* cast_other = static_cast<const MultiGrain*>(other);
assert(filters.size() == cast_other->filters.size());
for (int i = 0; i < filters.size(); ++i){
filters[i]->merge(cast_other->filters[i]);
@@ -62,7 +63,7 @@
}
void
-MultiGrainBloomFilter::set(Addr addr)
+MultiGrain::set(Addr addr)
{
for (auto& sub_filter : filters) {
sub_filter->set(addr);
@@ -70,7 +71,7 @@
}
void
-MultiGrainBloomFilter::unset(Addr addr)
+MultiGrain::unset(Addr addr)
{
for (auto& sub_filter : filters) {
sub_filter->unset(addr);
@@ -78,7 +79,7 @@
}
int
-MultiGrainBloomFilter::getCount(Addr addr) const
+MultiGrain::getCount(Addr addr) const
{
int count = 0;
for (const auto& sub_filter : filters) {
@@ -88,7 +89,7 @@
}
int
-MultiGrainBloomFilter::getTotalCount() const
+MultiGrain::getTotalCount() const
{
int count = 0;
for (const auto& sub_filter : filters) {
@@ -97,8 +98,11 @@
return count;
}
-MultiGrainBloomFilter*
-MultiGrainBloomFilterParams::create()
+} // namespace BloomFilter
+
+BloomFilter::MultiGrain*
+BloomFilterMultiGrainParams::create()
{
- return new MultiGrainBloomFilter(this);
+ return new BloomFilter::MultiGrain(this);
}
+
diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.hh
b/src/mem/ruby/filters/MultiGrainBloomFilter.hh
index 04c375e..d2788ca 100644
--- a/src/mem/ruby/filters/MultiGrainBloomFilter.hh
+++ b/src/mem/ruby/filters/MultiGrainBloomFilter.hh
@@ -33,30 +33,34 @@
#include "mem/ruby/filters/AbstractBloomFilter.hh"
-struct MultiGrainBloomFilterParams;
+struct BloomFilterMultiGrainParams;
+
+namespace BloomFilter {
/**
* This BloomFilter has multiple sub-filters, each with its own hashing
* functionality. The results of the operations are the results of applying
* them to each sub-filter.
*/
-class MultiGrainBloomFilter : public AbstractBloomFilter
+class MultiGrain : public Base
{
public:
- MultiGrainBloomFilter(const MultiGrainBloomFilterParams* p);
- ~MultiGrainBloomFilter();
+ MultiGrain(const BloomFilterMultiGrainParams* p);
+ ~MultiGrain();
void clear() override;
void set(Addr addr) override;
void unset(Addr addr) override;
- void merge(const AbstractBloomFilter* other) override;
+ void merge(const Base* other) override;
int getCount(Addr addr) const override;
int getTotalCount() const override;
private:
/** Sub-filters used by this filter. */
- std::vector<AbstractBloomFilter*> filters;
+ std::vector<Base*> filters;
};
+} // namespace BloomFilter
+
#endif // __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__
--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/18874
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: master
Gerrit-Change-Id: I3ee8cc225bf3b820e561c3e25a6bf38e0012e3a8
Gerrit-Change-Number: 18874
Gerrit-PatchSet: 1
Gerrit-Owner: Daniel Carvalho <[email protected]>
Gerrit-MessageType: newchange
_______________________________________________
gem5-dev mailing list
[email protected]
http://m5sim.org/mailman/listinfo/gem5-dev
