diff options
author | Daniel R. Carvalho <odanrc@yahoo.com.br> | 2019-05-11 23:19:48 +0200 |
---|---|---|
committer | Daniel Carvalho <odanrc@yahoo.com.br> | 2019-09-10 07:00:09 +0000 |
commit | 8d65e51f7f0fed279d2ecfc8601671e479b3387c (patch) | |
tree | ea8494924565def2c915ca4347431c76e9e42d0d /src/base/filters | |
parent | 9b9045bb67ac5f2cfa3306607635f347a3ee2f27 (diff) | |
download | gem5-8d65e51f7f0fed279d2ecfc8601671e479b3387c.tar.xz |
mem-ruby: Move Bloom Filters to base
All Bloom Filters are completely independent of Ruby, and
therefore can be used everywhere.
As a side effect, Ruby was not using the filters, so
their dependency was removed.
Change-Id: Ic5f430610c33c0791fb81c79101ebe737189497e
Signed-off-by: Daniel R. Carvalho <odanrc@yahoo.com.br>
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/18875
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Maintainer: Jason Lowe-Power <jason@lowepower.com>
Diffstat (limited to 'src/base/filters')
-rw-r--r-- | src/base/filters/BloomFilters.py | 104 | ||||
-rw-r--r-- | src/base/filters/SConscript | 42 | ||||
-rw-r--r-- | src/base/filters/base.hh | 151 | ||||
-rw-r--r-- | src/base/filters/block_bloom_filter.cc | 101 | ||||
-rw-r--r-- | src/base/filters/block_bloom_filter.hh | 75 | ||||
-rw-r--r-- | src/base/filters/bulk_bloom_filter.cc | 169 | ||||
-rw-r--r-- | src/base/filters/bulk_bloom_filter.hh | 66 | ||||
-rw-r--r-- | src/base/filters/h3_bloom_filter.cc | 401 | ||||
-rw-r--r-- | src/base/filters/h3_bloom_filter.hh | 57 | ||||
-rw-r--r-- | src/base/filters/lsb_counting_bloom_filter.cc | 98 | ||||
-rw-r--r-- | src/base/filters/lsb_counting_bloom_filter.hh | 62 | ||||
-rw-r--r-- | src/base/filters/multi_bit_sel_bloom_filter.cc | 106 | ||||
-rw-r--r-- | src/base/filters/multi_bit_sel_bloom_filter.hh | 82 | ||||
-rw-r--r-- | src/base/filters/multi_bloom_filter.cc | 121 | ||||
-rw-r--r-- | src/base/filters/multi_bloom_filter.hh | 70 |
15 files changed, 1705 insertions, 0 deletions
diff --git a/src/base/filters/BloomFilters.py b/src/base/filters/BloomFilters.py new file mode 100644 index 000000000..208b8a97a --- /dev/null +++ b/src/base/filters/BloomFilters.py @@ -0,0 +1,104 @@ +# 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 BloomFilterBase(SimObject): + type = 'BloomFilterBase' + abstract = True + cxx_header = "base/filters/base.hh" + cxx_class = 'BloomFilter::Base' + + size = Param.Int(4096, "Number of entries in the filter") + + # By default assume that bloom filters are used for 64-byte cache lines + offset_bits = Param.Unsigned(6, "Number of bits in a cache line offset") + + # 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 BloomFilterBlock(BloomFilterBase): + type = 'BloomFilterBlock' + cxx_class = 'BloomFilter::Block' + cxx_header = "base/filters/block_bloom_filter.hh" + + masks_lsbs = VectorParam.Unsigned([Self.offset_bits, + 2 * Self.offset_bits], "Position of the LSB of each mask") + masks_sizes = VectorParam.Unsigned([Self.offset_bits, Self.offset_bits], + "Size, in number of bits, of each mask") + +class BloomFilterBulk(BloomFilterBase): + type = 'BloomFilterBulk' + cxx_class = 'BloomFilter::Bulk' + cxx_header = "base/filters/bulk_bloom_filter.hh" + +class BloomFilterLSBCounting(BloomFilterBase): + type = 'BloomFilterLSBCounting' + cxx_class = 'BloomFilter::LSBCounting' + cxx_header = "base/filters/lsb_counting_bloom_filter.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 BloomFilterMultiBitSel(BloomFilterBase): + type = 'BloomFilterMultiBitSel' + cxx_class = 'BloomFilter::MultiBitSel' + cxx_header = "base/filters/multi_bit_sel_bloom_filter.hh" + + num_hashes = Param.Int(4, "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 BloomFilterH3(BloomFilterMultiBitSel): + type = 'BloomFilterH3' + cxx_class = 'BloomFilter::H3' + cxx_header = "base/filters/h3_bloom_filter.hh" + +class BloomFilterMulti(BloomFilterBase): + type = 'BloomFilterMulti' + cxx_class = 'BloomFilter::Multi' + cxx_header = "base/filters/multi_bloom_filter.hh" + + # The base filter should not be used, since this filter is the combination + # of multiple sub-filters, so we use a dummy value + size = 1 + + # By default there are two sub-filters that hash sequential bitfields + filters = VectorParam.BloomFilterBase([ + BloomFilterBlock(size = 4096, masks_lsbs = [6, 12]), + BloomFilterBlock(size = 1024, masks_lsbs = [18, 24])], + "Sub-filters to be combined") + + # By default match this with the number of sub-filters + threshold = 2 diff --git a/src/base/filters/SConscript b/src/base/filters/SConscript new file mode 100644 index 000000000..4c02ff122 --- /dev/null +++ b/src/base/filters/SConscript @@ -0,0 +1,42 @@ +# -*- mode:python -*- + +# Copyright (c) 2019 Inria +# Copyright (c) 2009 The Hewlett-Packard Development Company +# 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: Nathan Binkert +# Daniel Carvalho + +Import('*') + +SimObject('BloomFilters.py') + +Source('block_bloom_filter.cc') +Source('bulk_bloom_filter.cc') +Source('h3_bloom_filter.cc') +Source('lsb_counting_bloom_filter.cc') +Source('multi_bit_sel_bloom_filter.cc') +Source('multi_bloom_filter.cc') diff --git a/src/base/filters/base.hh b/src/base/filters/base.hh new file mode 100644 index 000000000..1ce853979 --- /dev/null +++ b/src/base/filters/base.hh @@ -0,0 +1,151 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_BASE_HH__ +#define __BASE_FILTERS_BASE_HH__ + +#include <vector> + +#include "base/intmath.hh" +#include "base/types.hh" +#include "params/BloomFilterBase.hh" +#include "sim/sim_object.hh" + +namespace BloomFilter { + +class Base : public SimObject +{ + protected: + /** Number of LSB bits to ignore from the the addresses. */ + const unsigned offsetBits; + + /** The filter itself. */ + std::vector<int> filter; + + /** Number of bits needed to represent the size of the filter. */ + const int sizeBits; + + /** Threshold at which a filter entry starts being considered as set. */ + const int setThreshold; + + public: + /** + * Create and clear the filter. + */ + Base(const BloomFilterBaseParams* p) + : SimObject(p), offsetBits(p->offset_bits), filter(p->size), + sizeBits(floorLog2(p->size)), setThreshold(p->threshold) + { + clear(); + } + virtual ~Base() {}; + + /** + * Clear the filter by resetting all values. + */ + virtual void clear() + { + for (auto& entry : filter) { + entry = 0; + } + } + + /** + * Merges the contents of both filters into this' (Bloom Filter union). + * Both must have the same number of entries. + * + * @param other The other bloom filter to merge with. + */ + virtual void + merge(const Base* other) + { + assert(filter.size() == other->filter.size()); + for (int i = 0; i < filter.size(); ++i){ + filter[i] |= other->filter[i]; + } + } + + /** + * Perform the filter specific function to set the corresponding + * entries (can be multiple) of an address. + * + * @param addr The address being parsed. + */ + virtual void set(Addr addr) = 0; + + /** + * Perform the filter specific function to clear the corresponding + * entries (can be multiple) of an address. By default a bloom + * filter does not support element deletion. + * + * @param addr The address being parsed. + */ + virtual void unset(Addr addr) {}; + + /** + * Check if the corresponding filter entries of an address should be + * considered as set. + * + * @param addr The address being parsed. + * @return Whether the respective filter entry is set. + */ + virtual bool + isSet(Addr addr) const + { + return getCount(addr) >= setThreshold; + } + + /** + * Get the value stored in the corresponding filter entry of an address. + * + * @param addr The address being parsed. + * @param Get the value stored in the respective filter entry. + */ + virtual int getCount(Addr addr) const { return 0; } + + /** + * Get the total value stored in the filter entries. + * + * @return The sum of all filter entries. + */ + virtual int getTotalCount() const + { + int count = 0; + for (const auto& entry : filter) { + count += entry; + } + return count; + } +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_BASE_HH__ diff --git a/src/base/filters/block_bloom_filter.cc b/src/base/filters/block_bloom_filter.cc new file mode 100644 index 000000000..45e3b725e --- /dev/null +++ b/src/base/filters/block_bloom_filter.cc @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#include "base/filters/block_bloom_filter.hh" + +#include "base/bitfield.hh" +#include "base/logging.hh" +#include "params/BloomFilterBlock.hh" + +namespace BloomFilter { + +Block::Block(const BloomFilterBlockParams* p) + : Base(p), masksLSBs(p->masks_lsbs), + masksSizes(p->masks_sizes) +{ + fatal_if(masksLSBs.size() != masksSizes.size(), + "Masks haven't been properly provided"); + fatal_if(masksLSBs.size() < 1, + "There must be at least one mask to extract an address bitfield"); + + for (int i = 0; i < masksLSBs.size(); i++) { + fatal_if((masksSizes[i] > sizeBits) || (masksSizes[i] <= 0), + "The bitfields must be indexable in the filter"); + fatal_if(masksLSBs[i] + masksSizes[i] > + std::numeric_limits<Addr>::digits, + "The total size of the bitfields cannot be bigger than the " \ + "number of bits in an address"); + } +} + +Block::~Block() +{ +} + +void +Block::set(Addr addr) +{ + filter[hash(addr)] = 1; +} + +void +Block::unset(Addr addr) +{ + filter[hash(addr)] = 0; +} + +int +Block::getCount(Addr addr) const +{ + return filter[hash(addr)]; +} + +int +Block::hash(Addr addr) const +{ + Addr hashed_addr = 0; + for (int i = 0; i < masksLSBs.size(); i++) { + hashed_addr ^= + bits(addr, offsetBits + masksLSBs[i] + masksSizes[i] - 1, + offsetBits + masksLSBs[i]); + } + assert(hashed_addr < filter.size()); + return hashed_addr; +} + +} // namespace BloomFilter + +BloomFilter::Block* +BloomFilterBlockParams::create() +{ + return new BloomFilter::Block(this); +} + diff --git a/src/base/filters/block_bloom_filter.hh b/src/base/filters/block_bloom_filter.hh new file mode 100644 index 000000000..9e7f7dbb0 --- /dev/null +++ b/src/base/filters/block_bloom_filter.hh @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_BLOCK_BLOOM_FILTER_HH__ +#define __BASE_FILTERS_BLOCK_BLOOM_FILTER_HH__ + +#include <vector> + +#include "base/filters/base.hh" + +struct BloomFilterBlockParams; + +namespace BloomFilter { + +/** + * Simple deletable (with false negatives) bloom filter that extracts + * bitfields of an address to use as indexes of the filter vector. + */ +class Block : public Base +{ + public: + Block(const BloomFilterBlockParams* p); + ~Block(); + + void set(Addr addr) override; + void unset(Addr addr) override; + int getCount(Addr addr) const override; + + private: + /** + * XOR hash between bitfields of an address, provided by the mask vector. + * + * @param addr The address to be hashed. + * @return The value of the XOR of the masked bitfields of the address. + */ + int hash(Addr addr) const; + + /** Position of the LSB of each mask. */ + std::vector<unsigned> masksLSBs; + + /** Number of bits in each mask. */ + std::vector<unsigned> masksSizes; +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_BLOCK_BLOOM_FILTER_HH__ diff --git a/src/base/filters/bulk_bloom_filter.cc b/src/base/filters/bulk_bloom_filter.cc new file mode 100644 index 000000000..6488086c2 --- /dev/null +++ b/src/base/filters/bulk_bloom_filter.cc @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#include "base/filters/bulk_bloom_filter.hh" + +#include <vector> + +#include <limits> + +#include "base/bitfield.hh" +#include "params/BloomFilterBulk.hh" + +namespace BloomFilter { + +Bulk::Bulk(const BloomFilterBulkParams* p) + : Base(p), sectorBits(sizeBits - 1) +{ +} + +Bulk::~Bulk() +{ +} + +void +Bulk::set(Addr addr) +{ + // c0 contains the cache index bits + int c0 = bits(addr, offsetBits + sectorBits - 1, offsetBits); + // c1 contains the lower sectorBits permuted bits + //Address permuted_bits = permute(addr); + int c1 = bits(addr, (offsetBits + 2 * sectorBits) - 1, + offsetBits + sectorBits); + //assert(c0 < (filter_size/2)); + //assert(c0 + (filter_size/2) < filter_size); + //assert(c1 < (filter_size/2)); + // set v0 bit + filter[c0 + (filter.size()/2)] = 1; + // set v1 bit + filter[c1] = 1; +} + +bool +Bulk::isSet(Addr addr) const +{ + // c0 contains the cache index bits + const int filter_size = filter.size(); + int c0 = bits(addr, offsetBits + sectorBits - 1, offsetBits); + // c1 contains the lower 10 permuted bits + //Address permuted_bits = permute(addr); + int c1 = bits(addr, (offsetBits + 2 * sectorBits) - 1, + offsetBits + sectorBits); + //assert(c0 < (filter_size/2)); + //assert(c0 + (filter_size/2) < filter_size); + //assert(c1 < (filter_size/2)); + // set v0 bit + std::vector<int> temp_filter(filter.size(), 0); + temp_filter[c0 + (filter_size/2)] = 1; + // set v1 bit + 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 < filter_size/2; ++i){ + // get intersection of signatures + temp_filter[i] = temp_filter[i] && filter[i]; + zero = zero || temp_filter[i]; + } + zero = !zero; + if (zero) { + // one section is zero, no possiblility of address in signature + // reset bits we just set + temp_filter[c0 + (filter_size / 2)] = 0; + temp_filter[c1] = 0; + return false; + } + + // check second section + zero = false; + for (int i = filter_size / 2; i < filter_size; ++i) { + // get intersection of signatures + temp_filter[i] = temp_filter[i] && filter[i]; + zero = zero || temp_filter[i]; + } + zero = !zero; + if (zero) { + // one section is zero, no possiblility of address in signature + temp_filter[c0 + (filter_size / 2)] = 0; + temp_filter[c1] = 0; + return false; + } + // one section has at least one bit set + temp_filter[c0 + (filter_size / 2)] = 0; + temp_filter[c1] = 0; + return true; +} + +int +Bulk::getCount(Addr addr) const +{ + // TODO as in the multi-hashed filters + return 0; +} + +Addr +Bulk::hash(Addr addr) const +{ + // permutes the original address bits according to Table 5 + Addr part1 = bits(addr, offsetBits + 6, offsetBits), + part2 = bits(addr, offsetBits + 9), + part3 = bits(addr, offsetBits + 11), + part4 = bits(addr, offsetBits + 17), + part5 = bits(addr, offsetBits + 8, offsetBits + 7), + part6 = bits(addr, offsetBits + 10), + part7 = bits(addr, offsetBits + 12), + part8 = bits(addr, offsetBits + 13), + part9 = bits(addr, offsetBits + 16, offsetBits + 15), + part10 = bits(addr, offsetBits + 20, offsetBits + 18), + part11 = bits(addr, offsetBits + 14); + + Addr result = + (part1 << 14) | (part2 << 13) | (part3 << 12) | (part4 << 11) | + (part5 << 9) | (part6 << 8) | (part7 << 7) | (part8 << 6) | + (part9 << 4) | (part10 << 1) | (part11); + + // Select the remaining high-order bits + Addr remaining_bits = bits(addr, std::numeric_limits<Addr>::digits - 1, + offsetBits + 21) << 21; + result = result | remaining_bits; + + return result; +} + +} // namespace BloomFilter + +BloomFilter::Bulk* +BloomFilterBulkParams::create() +{ + return new BloomFilter::Bulk(this); +} + diff --git a/src/base/filters/bulk_bloom_filter.hh b/src/base/filters/bulk_bloom_filter.hh new file mode 100644 index 000000000..7211aa2cd --- /dev/null +++ b/src/base/filters/bulk_bloom_filter.hh @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_BULK_BLOOM_FILTER_HH__ +#define __BASE_FILTERS_BULK_BLOOM_FILTER_HH__ + +#include "base/filters/base.hh" + +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 Bulk : public Base +{ + public: + Bulk(const BloomFilterBulkParams* p); + ~Bulk(); + + void set(Addr addr) override; + + bool isSet(Addr addr) const override; + int getCount(Addr addr) const override; + + private: + /** Permutes the address to generate its signature. */ + Addr hash(Addr addr) const; + + // split the filter bits in half, c0 and c1 + const int sectorBits; +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_BULK_BLOOM_FILTER_HH__ diff --git a/src/base/filters/h3_bloom_filter.cc b/src/base/filters/h3_bloom_filter.cc new file mode 100644 index 000000000..ca0899545 --- /dev/null +++ b/src/base/filters/h3_bloom_filter.cc @@ -0,0 +1,401 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#include "base/filters/h3_bloom_filter.hh" + +#include <limits> + +#include "base/bitfield.hh" +#include "base/logging.hh" +#include "params/BloomFilterH3.hh" + +namespace BloomFilter { + +static int H3Matrix[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, }, +}; + +H3::H3(const BloomFilterH3Params* p) + : MultiBitSel(p) +{ + fatal_if(numHashes > 16, "There are only 16 H3 functions implemented."); +} + +H3::~H3() +{ +} + +int +H3::hash(Addr addr, int hash_number) const +{ + uint64_t val = + bits(addr, std::numeric_limits<Addr>::digits - 1, offsetBits); + int result = 0; + + for (int i = 0; (i < 64) && val; i++, val >>= 1) { + if (val & 1) { + result ^= H3Matrix[i][hash_number]; + } + } + + if (isParallel) { + return (result % parFilterSize) + hash_number * parFilterSize; + } else { + return result % filter.size(); + } +} + +} // namespace BloomFilter + +BloomFilter::H3* +BloomFilterH3Params::create() +{ + return new BloomFilter::H3(this); +} + diff --git a/src/base/filters/h3_bloom_filter.hh b/src/base/filters/h3_bloom_filter.hh new file mode 100644 index 000000000..c90b40ff1 --- /dev/null +++ b/src/base/filters/h3_bloom_filter.hh @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_H3_BLOOM_FILTER_HH__ +#define __BASE_FILTERS_H3_BLOOM_FILTER_HH__ + +#include "base/filters/multi_bit_sel_bloom_filter.hh" + +struct BloomFilterH3Params; + +namespace BloomFilter { + +/** + * Implementation of the bloom filter as described in "Implementing Signatures + * for Transactional Memory", by Sanchez, Daniel, et al. + */ +class H3 : public MultiBitSel +{ + public: + H3(const BloomFilterH3Params* p); + ~H3(); + + protected: + int hash(Addr addr, int hash_number) const override; +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_H3_BLOOM_FILTER_HH__ diff --git a/src/base/filters/lsb_counting_bloom_filter.cc b/src/base/filters/lsb_counting_bloom_filter.cc new file mode 100644 index 000000000..16f858f01 --- /dev/null +++ b/src/base/filters/lsb_counting_bloom_filter.cc @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#include "base/filters/lsb_counting_bloom_filter.hh" + +#include "base/bitfield.hh" +#include "params/BloomFilterLSBCounting.hh" + +namespace BloomFilter { + +LSBCounting::LSBCounting( + const BloomFilterLSBCountingParams* p) + : Base(p), maxValue(p->max_value) +{ +} + +LSBCounting::~LSBCounting() +{ +} + +void +LSBCounting::merge(const Base* 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]) { + filter[i] += cast_other->filter[i]; + } else { + filter[i] = maxValue; + } + } +} + +void +LSBCounting::set(Addr addr) +{ + const int i = hash(addr); + if (filter[i] < maxValue) + filter[i] += 1; +} + +void +LSBCounting::unset(Addr addr) +{ + const int i = hash(addr); + if (filter[i] > 0) + filter[i] -= 1; +} + +int +LSBCounting::getCount(Addr addr) const +{ + return filter[hash(addr)]; +} + +int +LSBCounting::hash(Addr addr) const +{ + return bits(addr, offsetBits + sizeBits - 1, offsetBits); +} + +} // namespace BloomFilter + +BloomFilter::LSBCounting* +BloomFilterLSBCountingParams::create() +{ + return new BloomFilter::LSBCounting(this); +} + diff --git a/src/base/filters/lsb_counting_bloom_filter.hh b/src/base/filters/lsb_counting_bloom_filter.hh new file mode 100644 index 000000000..6da6fd681 --- /dev/null +++ b/src/base/filters/lsb_counting_bloom_filter.hh @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_LSB_COUNTING_BLOOM_FILTER_HH__ +#define __BASE_FILTERS_LSB_COUNTING_BLOOM_FILTER_HH__ + +#include "base/filters/base.hh" + +struct BloomFilterLSBCountingParams; + +namespace BloomFilter { + +class LSBCounting : public Base +{ + public: + LSBCounting(const BloomFilterLSBCountingParams* p); + ~LSBCounting(); + + void merge(const Base* other) override; + void set(Addr addr) override; + void unset(Addr addr) override; + + int getCount(Addr addr) const override; + + private: + int hash(Addr addr) const; + + /** Maximum value of the filter entries. */ + const int maxValue; +}; + +} // namespace BloomFilter + +#endif //__BASE_FILTERS_LSB_COUNTING_BLOOM_FILTER_HH__ diff --git a/src/base/filters/multi_bit_sel_bloom_filter.cc b/src/base/filters/multi_bit_sel_bloom_filter.cc new file mode 100644 index 000000000..efd20c315 --- /dev/null +++ b/src/base/filters/multi_bit_sel_bloom_filter.cc @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#include "base/filters/multi_bit_sel_bloom_filter.hh" + +#include <limits> + +#include "base/bitfield.hh" +#include "base/logging.hh" +#include "params/BloomFilterMultiBitSel.hh" + +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) +{ + if (p->size % numHashes) { + fatal("Can't divide filter (%d) in %d equal portions", p->size, + numHashes); + } +} + +MultiBitSel::~MultiBitSel() +{ +} + +void +MultiBitSel::set(Addr addr) +{ + for (int i = 0; i < numHashes; i++) { + int idx = hash(addr, i); + filter[idx] = 1; + } +} + +int +MultiBitSel::getCount(Addr addr) const +{ + int count = 0; + for (int i=0; i < numHashes; i++) { + count += filter[hash(addr, i)]; + } + return count; +} + +int +MultiBitSel::hash(Addr addr, int hash_number) const +{ + uint64_t value = bits(addr, std::numeric_limits<Addr>::digits - 1, + offsetBits) >> skipBits; + const int max_bits = std::numeric_limits<Addr>::digits - offsetBits; + int result = 0; + int bit, i; + + for (i = 0; i < sizeBits; i++) { + bit = (hash_number + numHashes * i) % max_bits; + if (value & (1 << bit)) { + result += 1 << i; + } + } + + if (isParallel) { + return (result % parFilterSize) + hash_number * parFilterSize; + } else { + return result % filter.size(); + } +} + +} // namespace BloomFilter + +BloomFilter::MultiBitSel* +BloomFilterMultiBitSelParams::create() +{ + return new BloomFilter::MultiBitSel(this); +} + diff --git a/src/base/filters/multi_bit_sel_bloom_filter.hh b/src/base/filters/multi_bit_sel_bloom_filter.hh new file mode 100644 index 000000000..d289bb302 --- /dev/null +++ b/src/base/filters/multi_bit_sel_bloom_filter.hh @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_MULTI_BIT_SEL_BLOOM_FILTER_HH__ +#define __BASE_FILTERS_MULTI_BIT_SEL_BLOOM_FILTER_HH__ + +#include "base/filters/base.hh" + +struct BloomFilterMultiBitSelParams; + +namespace BloomFilter { + +/** + * The MultiBitSel Bloom Filter associates an address to multiple entries + * through the use of multiple hash functions. + */ +class MultiBitSel : public Base +{ + public: + MultiBitSel(const BloomFilterMultiBitSelParams* p); + ~MultiBitSel(); + + void set(Addr addr) override; + int getCount(Addr addr) const override; + + protected: + /** + * Apply the selected the hash functions to an address. + * + * @param addr The address to hash. + * @param hash_number Index of the hash function to be used. + */ + virtual int hash(Addr addr, int hash_number) const; + + /** Number of hashes. */ + const int numHashes; + + /** Size of the filter when doing parallel hashing. */ + const int parFilterSize; + + /** Whether hashing should be performed in parallel. */ + const bool isParallel; + + private: + /** + * Bit offset from block number. Used to simulate bit selection hashing + * on larger than cache-line granularities, by skipping some bits. + */ + const int skipBits; +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_MULTI_BIT_SEL_BLOOM_FILTER_HH__ diff --git a/src/base/filters/multi_bloom_filter.cc b/src/base/filters/multi_bloom_filter.cc new file mode 100644 index 000000000..fb64bdf1e --- /dev/null +++ b/src/base/filters/multi_bloom_filter.cc @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#include "base/filters/multi_bloom_filter.hh" + +#include "base/logging.hh" +#include "params/BloomFilterMulti.hh" + +namespace BloomFilter { + +Multi::Multi(const BloomFilterMultiParams* p) + : Base(p), filters(p->filters) +{ +} + +Multi::~Multi() +{ +} + +void +Multi::clear() +{ + for (auto& sub_filter : filters) { + sub_filter->clear(); + } +} + +void +Multi::merge(const Base* other) +{ + auto* cast_other = static_cast<const Multi*>(other); + assert(filters.size() == cast_other->filters.size()); + for (int i = 0; i < filters.size(); ++i){ + filters[i]->merge(cast_other->filters[i]); + } +} + +void +Multi::set(Addr addr) +{ + for (auto& sub_filter : filters) { + sub_filter->set(addr); + } +} + +void +Multi::unset(Addr addr) +{ + for (auto& sub_filter : filters) { + sub_filter->unset(addr); + } +} + +bool +Multi::isSet(Addr addr) const +{ + int count = 0; + for (const auto& sub_filter : filters) { + if (sub_filter->isSet(addr)) { + count++; + } + } + return count >= setThreshold; +} + +int +Multi::getCount(Addr addr) const +{ + int count = 0; + for (const auto& sub_filter : filters) { + count += sub_filter->getCount(addr); + } + return count; +} + +int +Multi::getTotalCount() const +{ + int count = 0; + for (const auto& sub_filter : filters) { + count += sub_filter->getTotalCount(); + } + return count; +} + +} // namespace BloomFilter + +BloomFilter::Multi* +BloomFilterMultiParams::create() +{ + return new BloomFilter::Multi(this); +} + diff --git a/src/base/filters/multi_bloom_filter.hh b/src/base/filters/multi_bloom_filter.hh new file mode 100644 index 000000000..cb80a40f2 --- /dev/null +++ b/src/base/filters/multi_bloom_filter.hh @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2019 Inria + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * 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 + */ + +#ifndef __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__ +#define __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__ + +#include <vector> + +#include "base/filters/base.hh" + +struct BloomFilterMultiParams; + +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 Multi : public Base +{ + public: + Multi(const BloomFilterMultiParams* p); + ~Multi(); + + void clear() override; + void set(Addr addr) override; + void unset(Addr addr) override; + + void merge(const Base* other) override; + bool isSet(Addr addr) const override; + int getCount(Addr addr) const override; + int getTotalCount() const override; + + private: + /** Sub-filters used by this filter. */ + std::vector<Base*> filters; +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__ |