Make all bloom filters SimObjects.
Change-Id: I586293cdfb559361cb868b3198368e8b9b193356
Signed-off-by: Daniel R. Carvalho <odanrc@yahoo.com.br>
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/18736
Maintainer: Nikos Nikoleris <nikos.nikoleris@arm.com>
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Nikos Nikoleris <nikos.nikoleris@arm.com>
#include "base/intmath.hh"
#include "base/types.hh"
+#include "params/AbstractBloomFilter.hh"
+#include "sim/sim_object.hh"
-class AbstractBloomFilter
+class AbstractBloomFilter : public SimObject
{
protected:
/** The filter itself. */
public:
/**
* Create and clear the filter.
- *
- * @param size The number of filter entries.
- * @param threshold The threshold that limits a set entry.
*/
- AbstractBloomFilter(std::size_t size, int threshold)
- : filter(size), sizeBits(floorLog2(size)), setThreshold(threshold)
+ AbstractBloomFilter(const AbstractBloomFilterParams* p)
+ : SimObject(p), filter(p->size), sizeBits(floorLog2(p->size)),
+ setThreshold(p->threshold)
{
clear();
}
#include "mem/ruby/common/Address.hh"
#include "mem/ruby/system/RubySystem.hh"
+#include "params/BlockBloomFilter.hh"
-BlockBloomFilter::BlockBloomFilter(int size)
- : AbstractBloomFilter(size, 1)
+BlockBloomFilter::BlockBloomFilter(const BlockBloomFilterParams* p)
+ : AbstractBloomFilter(p)
{
}
return index;
}
-
+BlockBloomFilter*
+BlockBloomFilterParams::create()
+{
+ return new BlockBloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct BlockBloomFilterParams;
+
class BlockBloomFilter : public AbstractBloomFilter
{
public:
- BlockBloomFilter(int size);
+ BlockBloomFilter(const BlockBloomFilterParams* p);
~BlockBloomFilter();
void set(Addr addr) override;
--- /dev/null
+# Copyright (c) 2019 Inria
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Authors: Daniel Carvalho
+
+from m5.params import *
+from m5.proxy import *
+from m5.SimObject import SimObject
+
+class AbstractBloomFilter(SimObject):
+ type = 'AbstractBloomFilter'
+ abstract = True
+ cxx_header = "mem/ruby/filters/AbstractBloomFilter.hh"
+
+ size = Param.Int(4096, "Number of entries in the filter")
+
+ # 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'
+ cxx_header = "mem/ruby/filters/BlockBloomFilter.hh"
+
+class BulkBloomFilter(AbstractBloomFilter):
+ type = 'BulkBloomFilter'
+ cxx_class = 'BulkBloomFilter'
+ cxx_header = "mem/ruby/filters/BulkBloomFilter.hh"
+
+class H3BloomFilter(AbstractBloomFilter):
+ type = 'H3BloomFilter'
+ cxx_class = 'H3BloomFilter'
+ cxx_header = "mem/ruby/filters/H3BloomFilter.hh"
+
+ num_hashes = Param.Int(3, "Number of hashes")
+ threshold = Self.num_hashes
+ is_parallel = Param.Bool(False, "Whether hashing is done in parallel")
+
+class LSB_CountingBloomFilter(AbstractBloomFilter):
+ type = 'LSB_CountingBloomFilter'
+ cxx_class = 'LSB_CountingBloomFilter'
+ cxx_header = "mem/ruby/filters/LSB_CountingBloomFilter.hh"
+
+ # By default use 4-bit saturating counters
+ max_value = Param.Int(15, "Maximum value of the filter entries")
+
+ # We assume that isSet will return true only when the counter saturates
+ threshold = Self.max_value
+
+class MultiBitSelBloomFilter(AbstractBloomFilter):
+ type = 'MultiBitSelBloomFilter'
+ cxx_class = 'MultiBitSelBloomFilter'
+ cxx_header = "mem/ruby/filters/MultiBitSelBloomFilter.hh"
+
+ num_hashes = Param.Int(3, "Number of hashes")
+ threshold = Self.num_hashes
+ skip_bits = Param.Int(2, "Offset from block number")
+ is_parallel = Param.Bool(False, "Whether hashing is done in parallel")
+
+class MultiGrainBloomFilter(AbstractBloomFilter):
+ type = 'MultiGrainBloomFilter'
+ cxx_class = 'MultiGrainBloomFilter'
+ cxx_header = "mem/ruby/filters/MultiGrainBloomFilter.hh"
+
+ # This is the maximum value achievable of the sum of the hashed respective
+ # entry of the two filters
+ threshold = 2
+ page_filter_size = Param.Int(1024, "Number of entries in the page filter")
+
+class NonCountingBloomFilter(AbstractBloomFilter):
+ type = 'NonCountingBloomFilter'
+ cxx_class = 'NonCountingBloomFilter'
+ cxx_header = "mem/ruby/filters/NonCountingBloomFilter.hh"
+
+ skip_bits = Param.Int(2, "Offset from block number")
#include "mem/ruby/common/Address.hh"
#include "mem/ruby/system/RubySystem.hh"
+#include "params/BulkBloomFilter.hh"
-BulkBloomFilter::BulkBloomFilter(int size)
- : AbstractBloomFilter(size, 1), sectorBits(sizeBits - 1)
+BulkBloomFilter::BulkBloomFilter(const BulkBloomFilterParams* p)
+ : AbstractBloomFilter(p), sectorBits(sizeBits - 1)
{
}
return result;
}
+
+BulkBloomFilter*
+BulkBloomFilterParams::create()
+{
+ return new BulkBloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct BulkBloomFilterParams;
+
/**
* Implementation of the bloom filter, as described in "Bulk Disambiguation of
* Speculative Threads in Multiprocessors", by Ceze, Luis, et al.
class BulkBloomFilter : public AbstractBloomFilter
{
public:
- BulkBloomFilter(int size);
+ BulkBloomFilter(const BulkBloomFilterParams* p);
~BulkBloomFilter();
void set(Addr addr) override;
#include "base/logging.hh"
#include "mem/ruby/common/Address.hh"
+#include "params/H3BloomFilter.hh"
static int H3[64][16] = {
{ 33268410, 395488709, 311024285, 456111753,
394261773, 848616745, 15446017, 517723271, },
};
-H3BloomFilter::H3BloomFilter(int size, int num_hashes, bool parallel)
- : AbstractBloomFilter(size, num_hashes), numHashes(num_hashes),
- isParallel(parallel), parFilterSize(filter.size() / numHashes)
+H3BloomFilter::H3BloomFilter(const H3BloomFilterParams* p)
+ : AbstractBloomFilter(p), numHashes(p->num_hashes),
+ isParallel(p->is_parallel), parFilterSize(p->size / numHashes)
{
fatal_if(numHashes > 16, "There are only 16 hash functions implemented.");
}
return result;
}
+H3BloomFilter*
+H3BloomFilterParams::create()
+{
+ return new H3BloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct H3BloomFilterParams;
+
/**
* Implementation of the bloom filter as described in "Implementing Signatures
* for Transactional Memory", by Sanchez, Daniel, et al.
class H3BloomFilter : public AbstractBloomFilter
{
public:
- H3BloomFilter(int size, int num_hashes, bool parallel);
+ H3BloomFilter(const H3BloomFilterParams* p);
~H3BloomFilter();
void merge(const AbstractBloomFilter* other) override;
#include "mem/ruby/common/Address.hh"
#include "mem/ruby/system/RubySystem.hh"
+#include "params/LSB_CountingBloomFilter.hh"
-LSB_CountingBloomFilter::LSB_CountingBloomFilter(std::size_t filter_size,
- int max_value)
- // Here we assume that isSet will return true only when the counter
- // saturates
- : AbstractBloomFilter(filter_size, max_value), maxValue(max_value)
+LSB_CountingBloomFilter::LSB_CountingBloomFilter(
+ const LSB_CountingBloomFilterParams* p)
+ : AbstractBloomFilter(p), maxValue(p->max_value)
{
}
sizeBits - 1);
}
-
+LSB_CountingBloomFilter*
+LSB_CountingBloomFilterParams::create()
+{
+ return new LSB_CountingBloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct LSB_CountingBloomFilterParams;
+
class LSB_CountingBloomFilter : public AbstractBloomFilter
{
public:
- LSB_CountingBloomFilter(std::size_t filter_size, int max_value);
+ LSB_CountingBloomFilter(const LSB_CountingBloomFilterParams* p);
~LSB_CountingBloomFilter();
void set(Addr addr) override;
#include "mem/ruby/filters/MultiBitSelBloomFilter.hh"
#include "mem/ruby/common/Address.hh"
+#include "params/MultiBitSelBloomFilter.hh"
-MultiBitSelBloomFilter::MultiBitSelBloomFilter(std::size_t filter_size,
- int num_hashes, int skip_bits, bool is_parallel)
- : AbstractBloomFilter(filter_size, num_hashes), numHashes(num_hashes),
- skipBits(skip_bits),
- parFilterSize(filter_size / numHashes),
- isParallel(is_parallel)
+MultiBitSelBloomFilter::MultiBitSelBloomFilter(
+ const MultiBitSelBloomFilterParams* p)
+ : AbstractBloomFilter(p), numHashes(p->num_hashes),
+ skipBits(p->skip_bits),
+ parFilterSize(p->size / numHashes),
+ isParallel(p->is_parallel)
{
}
}
return result;
}
+
+MultiBitSelBloomFilter*
+MultiBitSelBloomFilterParams::create()
+{
+ return new MultiBitSelBloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct MultiBitSelBloomFilterParams;
+
class MultiBitSelBloomFilter : public AbstractBloomFilter
{
public:
- MultiBitSelBloomFilter(std::size_t filter_size, int num_hashes,
- int skip_bits, bool is_parallel);
+ MultiBitSelBloomFilter(const MultiBitSelBloomFilterParams* p);
~MultiBitSelBloomFilter();
void merge(const AbstractBloomFilter* other) override;
#include "mem/ruby/common/Address.hh"
#include "mem/ruby/system/RubySystem.hh"
+#include "params/MultiGrainBloomFilter.hh"
-MultiGrainBloomFilter::MultiGrainBloomFilter(int head, int tail)
- : AbstractBloomFilter(head, 2),
- pageFilter(tail), pageFilterSizeBits(floorLog2(tail))
+MultiGrainBloomFilter::MultiGrainBloomFilter(
+ const MultiGrainBloomFilterParams* p)
+ : AbstractBloomFilter(p), pageFilter(p->page_filter_size),
+ pageFilterSizeBits(floorLog2(p->page_filter_size))
{
}
return bitSelect(addr, bits, bits + pageFilterSizeBits - 1);
}
-
-
-
+MultiGrainBloomFilter*
+MultiGrainBloomFilterParams::create()
+{
+ return new MultiGrainBloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct MultiGrainBloomFilterParams;
+
class MultiGrainBloomFilter : public AbstractBloomFilter
{
public:
- /**
- * @param head Size of 1st bloom filter.
- * @param tail size of 2nd bloom filter.
- */
- MultiGrainBloomFilter(int head, int tail);
+ MultiGrainBloomFilter(const MultiGrainBloomFilterParams* p);
~MultiGrainBloomFilter();
void clear() override;
#include "mem/ruby/common/Address.hh"
#include "mem/ruby/system/RubySystem.hh"
+#include "params/NonCountingBloomFilter.hh"
-NonCountingBloomFilter::NonCountingBloomFilter(std::size_t size, int skip_bits)
- : AbstractBloomFilter(size, 1), skipBits(skip_bits)
+NonCountingBloomFilter::NonCountingBloomFilter(
+ const NonCountingBloomFilterParams* p)
+ : AbstractBloomFilter(p), skipBits(p->skip_bits)
{
}
sizeBits - 1);
}
-
+NonCountingBloomFilter*
+NonCountingBloomFilterParams::create()
+{
+ return new NonCountingBloomFilter(this);
+}
#include "mem/ruby/filters/AbstractBloomFilter.hh"
+struct NonCountingBloomFilterParams;
+
class NonCountingBloomFilter : public AbstractBloomFilter
{
public:
- NonCountingBloomFilter(std::size_t filter_size, int skip_bits);
+ NonCountingBloomFilter(const NonCountingBloomFilterParams* p);
~NonCountingBloomFilter();
void merge(const AbstractBloomFilter* other) override;
if env['PROTOCOL'] == 'None':
Return()
+SimObject('BloomFilters.py')
+
Source('BlockBloomFilter.cc')
Source('BulkBloomFilter.cc')
Source('H3BloomFilter.cc')
projects / gem5.git / commitdiff