From: Daniel R. Carvalho Date: Mon, 6 May 2019 21:49:21 +0000 (+0200) Subject: mem-ruby: Make Bloom Filters SimObjects X-Git-Tag: v19.0.0.0~743 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=aa1b00ee899976fc12722f9f6d319202322c28d8;p=gem5.git mem-ruby: Make Bloom Filters SimObjects Make all bloom filters SimObjects. Change-Id: I586293cdfb559361cb868b3198368e8b9b193356 Signed-off-by: Daniel R. Carvalho Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/18736 Maintainer: Nikos Nikoleris Tested-by: kokoro Reviewed-by: Nikos Nikoleris --- diff --git a/src/mem/ruby/filters/AbstractBloomFilter.hh b/src/mem/ruby/filters/AbstractBloomFilter.hh index 672236527..301a78122 100644 --- a/src/mem/ruby/filters/AbstractBloomFilter.hh +++ b/src/mem/ruby/filters/AbstractBloomFilter.hh @@ -36,8 +36,10 @@ #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. */ @@ -52,12 +54,10 @@ class AbstractBloomFilter 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(); } diff --git a/src/mem/ruby/filters/BlockBloomFilter.cc b/src/mem/ruby/filters/BlockBloomFilter.cc index f59a17547..a93e8ff2c 100644 --- a/src/mem/ruby/filters/BlockBloomFilter.cc +++ b/src/mem/ruby/filters/BlockBloomFilter.cc @@ -30,9 +30,10 @@ #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) { } @@ -76,4 +77,8 @@ BlockBloomFilter::hash(Addr addr) const return index; } - +BlockBloomFilter* +BlockBloomFilterParams::create() +{ + return new BlockBloomFilter(this); +} diff --git a/src/mem/ruby/filters/BlockBloomFilter.hh b/src/mem/ruby/filters/BlockBloomFilter.hh index fd75ba890..c38662461 100644 --- a/src/mem/ruby/filters/BlockBloomFilter.hh +++ b/src/mem/ruby/filters/BlockBloomFilter.hh @@ -31,10 +31,12 @@ #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; diff --git a/src/mem/ruby/filters/BloomFilters.py b/src/mem/ruby/filters/BloomFilters.py new file mode 100644 index 000000000..49ebaa3bf --- /dev/null +++ b/src/mem/ruby/filters/BloomFilters.py @@ -0,0 +1,98 @@ +# 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") diff --git a/src/mem/ruby/filters/BulkBloomFilter.cc b/src/mem/ruby/filters/BulkBloomFilter.cc index 251274bd6..f2a2108b0 100644 --- a/src/mem/ruby/filters/BulkBloomFilter.cc +++ b/src/mem/ruby/filters/BulkBloomFilter.cc @@ -30,9 +30,10 @@ #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) { } @@ -155,3 +156,9 @@ BulkBloomFilter::hash(Addr addr) const return result; } + +BulkBloomFilter* +BulkBloomFilterParams::create() +{ + return new BulkBloomFilter(this); +} diff --git a/src/mem/ruby/filters/BulkBloomFilter.hh b/src/mem/ruby/filters/BulkBloomFilter.hh index 7be00e673..54c976a91 100644 --- a/src/mem/ruby/filters/BulkBloomFilter.hh +++ b/src/mem/ruby/filters/BulkBloomFilter.hh @@ -33,6 +33,8 @@ #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. @@ -40,7 +42,7 @@ class BulkBloomFilter : public AbstractBloomFilter { public: - BulkBloomFilter(int size); + BulkBloomFilter(const BulkBloomFilterParams* p); ~BulkBloomFilter(); void set(Addr addr) override; diff --git a/src/mem/ruby/filters/H3BloomFilter.cc b/src/mem/ruby/filters/H3BloomFilter.cc index 485cc3169..2b641722b 100644 --- a/src/mem/ruby/filters/H3BloomFilter.cc +++ b/src/mem/ruby/filters/H3BloomFilter.cc @@ -30,6 +30,7 @@ #include "base/logging.hh" #include "mem/ruby/common/Address.hh" +#include "params/H3BloomFilter.hh" static int H3[64][16] = { { 33268410, 395488709, 311024285, 456111753, @@ -353,9 +354,9 @@ static int H3[64][16] = { 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."); } @@ -419,3 +420,8 @@ H3BloomFilter::hashH3(uint64_t value, int index) const return result; } +H3BloomFilter* +H3BloomFilterParams::create() +{ + return new H3BloomFilter(this); +} diff --git a/src/mem/ruby/filters/H3BloomFilter.hh b/src/mem/ruby/filters/H3BloomFilter.hh index f92878b45..62a8ec1a1 100644 --- a/src/mem/ruby/filters/H3BloomFilter.hh +++ b/src/mem/ruby/filters/H3BloomFilter.hh @@ -31,6 +31,8 @@ #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. @@ -38,7 +40,7 @@ class H3BloomFilter : public AbstractBloomFilter { public: - H3BloomFilter(int size, int num_hashes, bool parallel); + H3BloomFilter(const H3BloomFilterParams* p); ~H3BloomFilter(); void merge(const AbstractBloomFilter* other) override; diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc index a718b4344..0d899a76e 100644 --- a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc +++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc @@ -30,12 +30,11 @@ #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) { } @@ -73,4 +72,8 @@ LSB_CountingBloomFilter::hash(Addr addr) const sizeBits - 1); } - +LSB_CountingBloomFilter* +LSB_CountingBloomFilterParams::create() +{ + return new LSB_CountingBloomFilter(this); +} diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh index e9ffbcbd1..4bc0441da 100644 --- a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh +++ b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh @@ -31,10 +31,12 @@ #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; diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc index c453d10bf..88fb8d366 100644 --- a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc +++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc @@ -29,13 +29,14 @@ #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) { } @@ -100,3 +101,9 @@ MultiBitSelBloomFilter::hashBitsel(uint64_t value, int index, int jump, } return result; } + +MultiBitSelBloomFilter* +MultiBitSelBloomFilterParams::create() +{ + return new MultiBitSelBloomFilter(this); +} diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh index 914875f85..501483dac 100644 --- a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh +++ b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh @@ -31,11 +31,12 @@ #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; diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.cc b/src/mem/ruby/filters/MultiGrainBloomFilter.cc index 7bf9dfe01..8360564c9 100644 --- a/src/mem/ruby/filters/MultiGrainBloomFilter.cc +++ b/src/mem/ruby/filters/MultiGrainBloomFilter.cc @@ -30,10 +30,12 @@ #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)) { } @@ -100,6 +102,8 @@ MultiGrainBloomFilter::pageHash(Addr addr) const return bitSelect(addr, bits, bits + pageFilterSizeBits - 1); } - - - +MultiGrainBloomFilter* +MultiGrainBloomFilterParams::create() +{ + return new MultiGrainBloomFilter(this); +} diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.hh b/src/mem/ruby/filters/MultiGrainBloomFilter.hh index d45b58708..e89578805 100644 --- a/src/mem/ruby/filters/MultiGrainBloomFilter.hh +++ b/src/mem/ruby/filters/MultiGrainBloomFilter.hh @@ -33,14 +33,12 @@ #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; diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.cc b/src/mem/ruby/filters/NonCountingBloomFilter.cc index 3196eb64f..61bc26f60 100644 --- a/src/mem/ruby/filters/NonCountingBloomFilter.cc +++ b/src/mem/ruby/filters/NonCountingBloomFilter.cc @@ -30,9 +30,11 @@ #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) { } @@ -76,4 +78,8 @@ NonCountingBloomFilter::hash(Addr addr) const sizeBits - 1); } - +NonCountingBloomFilter* +NonCountingBloomFilterParams::create() +{ + return new NonCountingBloomFilter(this); +} diff --git a/src/mem/ruby/filters/NonCountingBloomFilter.hh b/src/mem/ruby/filters/NonCountingBloomFilter.hh index 1553bec0b..614fee00f 100644 --- a/src/mem/ruby/filters/NonCountingBloomFilter.hh +++ b/src/mem/ruby/filters/NonCountingBloomFilter.hh @@ -31,10 +31,12 @@ #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; diff --git a/src/mem/ruby/filters/SConscript b/src/mem/ruby/filters/SConscript index 5b7e58334..13ecc5e18 100644 --- a/src/mem/ruby/filters/SConscript +++ b/src/mem/ruby/filters/SConscript @@ -33,6 +33,8 @@ Import('*') if env['PROTOCOL'] == 'None': Return() +SimObject('BloomFilters.py') + Source('BlockBloomFilter.cc') Source('BulkBloomFilter.cc') Source('H3BloomFilter.cc')