From 8d65e51f7f0fed279d2ecfc8601671e479b3387c Mon Sep 17 00:00:00 2001 From: "Daniel R. Carvalho" Date: Sat, 11 May 2019 23:19:48 +0200 Subject: 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 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/18875 Tested-by: kokoro Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power --- src/base/filters/BloomFilters.py | 104 ++++++ src/base/filters/SConscript | 42 +++ src/base/filters/base.hh | 151 +++++++++ src/base/filters/block_bloom_filter.cc | 101 ++++++ src/base/filters/block_bloom_filter.hh | 75 +++++ src/base/filters/bulk_bloom_filter.cc | 169 ++++++++++ src/base/filters/bulk_bloom_filter.hh | 66 ++++ src/base/filters/h3_bloom_filter.cc | 401 ++++++++++++++++++++++++ src/base/filters/h3_bloom_filter.hh | 57 ++++ src/base/filters/lsb_counting_bloom_filter.cc | 98 ++++++ src/base/filters/lsb_counting_bloom_filter.hh | 62 ++++ src/base/filters/multi_bit_sel_bloom_filter.cc | 106 +++++++ src/base/filters/multi_bit_sel_bloom_filter.hh | 82 +++++ src/base/filters/multi_bloom_filter.cc | 121 +++++++ src/base/filters/multi_bloom_filter.hh | 70 +++++ src/mem/ruby/SConscript | 1 - src/mem/ruby/filters/AbstractBloomFilter.hh | 151 --------- src/mem/ruby/filters/BlockBloomFilter.cc | 98 ------ src/mem/ruby/filters/BlockBloomFilter.hh | 72 ----- src/mem/ruby/filters/BloomFilters.py | 104 ------ src/mem/ruby/filters/BulkBloomFilter.cc | 164 ---------- src/mem/ruby/filters/BulkBloomFilter.hh | 65 ---- src/mem/ruby/filters/H3BloomFilter.cc | 398 ----------------------- src/mem/ruby/filters/H3BloomFilter.hh | 54 ---- src/mem/ruby/filters/LSB_CountingBloomFilter.cc | 95 ------ src/mem/ruby/filters/LSB_CountingBloomFilter.hh | 59 ---- src/mem/ruby/filters/MultiBitSelBloomFilter.cc | 103 ------ src/mem/ruby/filters/MultiBitSelBloomFilter.hh | 79 ----- src/mem/ruby/filters/MultiGrainBloomFilter.cc | 118 ------- src/mem/ruby/filters/MultiGrainBloomFilter.hh | 67 ---- src/mem/ruby/filters/SConscript | 43 --- src/mem/ruby/protocol/RubySlicc_Types.sm | 9 - 32 files changed, 1705 insertions(+), 1680 deletions(-) create mode 100644 src/base/filters/BloomFilters.py create mode 100644 src/base/filters/SConscript create mode 100644 src/base/filters/base.hh create mode 100644 src/base/filters/block_bloom_filter.cc create mode 100644 src/base/filters/block_bloom_filter.hh create mode 100644 src/base/filters/bulk_bloom_filter.cc create mode 100644 src/base/filters/bulk_bloom_filter.hh create mode 100644 src/base/filters/h3_bloom_filter.cc create mode 100644 src/base/filters/h3_bloom_filter.hh create mode 100644 src/base/filters/lsb_counting_bloom_filter.cc create mode 100644 src/base/filters/lsb_counting_bloom_filter.hh create mode 100644 src/base/filters/multi_bit_sel_bloom_filter.cc create mode 100644 src/base/filters/multi_bit_sel_bloom_filter.hh create mode 100644 src/base/filters/multi_bloom_filter.cc create mode 100644 src/base/filters/multi_bloom_filter.hh delete mode 100644 src/mem/ruby/filters/AbstractBloomFilter.hh delete mode 100644 src/mem/ruby/filters/BlockBloomFilter.cc delete mode 100644 src/mem/ruby/filters/BlockBloomFilter.hh delete mode 100644 src/mem/ruby/filters/BloomFilters.py delete mode 100644 src/mem/ruby/filters/BulkBloomFilter.cc delete mode 100644 src/mem/ruby/filters/BulkBloomFilter.hh delete mode 100644 src/mem/ruby/filters/H3BloomFilter.cc delete mode 100644 src/mem/ruby/filters/H3BloomFilter.hh delete mode 100644 src/mem/ruby/filters/LSB_CountingBloomFilter.cc delete mode 100644 src/mem/ruby/filters/LSB_CountingBloomFilter.hh delete mode 100644 src/mem/ruby/filters/MultiBitSelBloomFilter.cc delete mode 100644 src/mem/ruby/filters/MultiBitSelBloomFilter.hh delete mode 100644 src/mem/ruby/filters/MultiGrainBloomFilter.cc delete mode 100644 src/mem/ruby/filters/MultiGrainBloomFilter.hh delete mode 100644 src/mem/ruby/filters/SConscript 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 + +#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 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::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 + +#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 masksLSBs; + + /** Number of bits in each mask. */ + std::vector 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 + +#include + +#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 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::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 + +#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::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(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 + +#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::digits - 1, + offsetBits) >> skipBits; + const int max_bits = std::numeric_limits::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(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 + +#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 filters; +}; + +} // namespace BloomFilter + +#endif // __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__ diff --git a/src/mem/ruby/SConscript b/src/mem/ruby/SConscript index 22dd973c3..450a4bfca 100644 --- a/src/mem/ruby/SConscript +++ b/src/mem/ruby/SConscript @@ -125,7 +125,6 @@ MakeInclude('common/MachineID.hh') MakeInclude('common/NetDest.hh') MakeInclude('common/Set.hh') MakeInclude('common/WriteMask.hh') -MakeInclude('filters/AbstractBloomFilter.hh') MakeInclude('network/MessageBuffer.hh') MakeInclude('structures/CacheMemory.hh') MakeInclude('structures/DirectoryMemory.hh') diff --git a/src/mem/ruby/filters/AbstractBloomFilter.hh b/src/mem/ruby/filters/AbstractBloomFilter.hh deleted file mode 100644 index b2bfa4d3e..000000000 --- a/src/mem/ruby/filters/AbstractBloomFilter.hh +++ /dev/null @@ -1,151 +0,0 @@ -/* - * 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 __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__ - -#include - -#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 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 // __MEM_RUBY_FILTERS_ABSTRACTBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/BlockBloomFilter.cc b/src/mem/ruby/filters/BlockBloomFilter.cc deleted file mode 100644 index 5fe1fbbde..000000000 --- a/src/mem/ruby/filters/BlockBloomFilter.cc +++ /dev/null @@ -1,98 +0,0 @@ -/* - * 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. - */ - -#include "mem/ruby/filters/BlockBloomFilter.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::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/mem/ruby/filters/BlockBloomFilter.hh b/src/mem/ruby/filters/BlockBloomFilter.hh deleted file mode 100644 index 880dd9d4b..000000000 --- a/src/mem/ruby/filters/BlockBloomFilter.hh +++ /dev/null @@ -1,72 +0,0 @@ -/* - * 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. - */ - -#ifndef __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__ - -#include - -#include "mem/ruby/filters/AbstractBloomFilter.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 masksLSBs; - - /** Number of bits in each mask. */ - std::vector masksSizes; -}; - -} // namespace BloomFilter - -#endif // __MEM_RUBY_FILTERS_BLOCKBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/BloomFilters.py b/src/mem/ruby/filters/BloomFilters.py deleted file mode 100644 index 058c50405..000000000 --- a/src/mem/ruby/filters/BloomFilters.py +++ /dev/null @@ -1,104 +0,0 @@ -# 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 = "mem/ruby/filters/AbstractBloomFilter.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 = "mem/ruby/filters/BlockBloomFilter.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 = "mem/ruby/filters/BulkBloomFilter.hh" - -class BloomFilterLSBCounting(BloomFilterBase): - type = 'BloomFilterLSBCounting' - cxx_class = 'BloomFilter::LSBCounting' - 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 BloomFilterMultiBitSel(BloomFilterBase): - type = 'BloomFilterMultiBitSel' - cxx_class = 'BloomFilter::MultiBitSel' - cxx_header = "mem/ruby/filters/MultiBitSelBloomFilter.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 = "mem/ruby/filters/H3BloomFilter.hh" - -class BloomFilterMultiGrain(BloomFilterBase): - type = 'BloomFilterMultiGrain' - cxx_class = 'BloomFilter::MultiGrain' - cxx_header = "mem/ruby/filters/MultiGrainBloomFilter.hh" - - # The base filter should not be used, since this filter is the combination - # 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/mem/ruby/filters/BulkBloomFilter.cc b/src/mem/ruby/filters/BulkBloomFilter.cc deleted file mode 100644 index 669b879ee..000000000 --- a/src/mem/ruby/filters/BulkBloomFilter.cc +++ /dev/null @@ -1,164 +0,0 @@ -/* - * 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. - */ - -#include "mem/ruby/filters/BulkBloomFilter.hh" - -#include - -#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 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::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/mem/ruby/filters/BulkBloomFilter.hh b/src/mem/ruby/filters/BulkBloomFilter.hh deleted file mode 100644 index 8eb6edf14..000000000 --- a/src/mem/ruby/filters/BulkBloomFilter.hh +++ /dev/null @@ -1,65 +0,0 @@ -/* - * 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. - */ - -#ifndef __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__ - -#include - -#include "mem/ruby/filters/AbstractBloomFilter.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 // __MEM_RUBY_FILTERS_BULKBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/H3BloomFilter.cc b/src/mem/ruby/filters/H3BloomFilter.cc deleted file mode 100644 index 3a4ba0cef..000000000 --- a/src/mem/ruby/filters/H3BloomFilter.cc +++ /dev/null @@ -1,398 +0,0 @@ -/* - * 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. - */ - -#include "mem/ruby/filters/H3BloomFilter.hh" - -#include - -#include "base/logging.hh" -#include "base/bitfield.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::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/mem/ruby/filters/H3BloomFilter.hh b/src/mem/ruby/filters/H3BloomFilter.hh deleted file mode 100644 index 6235c028c..000000000 --- a/src/mem/ruby/filters/H3BloomFilter.hh +++ /dev/null @@ -1,54 +0,0 @@ -/* - * 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. - */ - -#ifndef __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__ - -#include "mem/ruby/filters/MultiBitSelBloomFilter.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 // __MEM_RUBY_FILTERS_H3BLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc b/src/mem/ruby/filters/LSB_CountingBloomFilter.cc deleted file mode 100644 index 9e0e8d2c5..000000000 --- a/src/mem/ruby/filters/LSB_CountingBloomFilter.cc +++ /dev/null @@ -1,95 +0,0 @@ -/* - * 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. - */ - -#include "mem/ruby/filters/LSB_CountingBloomFilter.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(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/mem/ruby/filters/LSB_CountingBloomFilter.hh b/src/mem/ruby/filters/LSB_CountingBloomFilter.hh deleted file mode 100644 index efc6b67a2..000000000 --- a/src/mem/ruby/filters/LSB_CountingBloomFilter.hh +++ /dev/null @@ -1,59 +0,0 @@ -/* - * 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. - */ - -#ifndef __MEM_RUBY_FILTERS_LSB_COUNTINGBLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_LSB_COUNTINGBLOOMFILTER_HH__ - -#include "mem/ruby/filters/AbstractBloomFilter.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 //__MEM_RUBY_FILTERS_LSB_COUNTINGBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc b/src/mem/ruby/filters/MultiBitSelBloomFilter.cc deleted file mode 100644 index beca335aa..000000000 --- a/src/mem/ruby/filters/MultiBitSelBloomFilter.cc +++ /dev/null @@ -1,103 +0,0 @@ -/* - * 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. - */ - -#include "mem/ruby/filters/MultiBitSelBloomFilter.hh" - -#include - -#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::digits - 1, - offsetBits) >> skipBits; - const int max_bits = std::numeric_limits::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/mem/ruby/filters/MultiBitSelBloomFilter.hh b/src/mem/ruby/filters/MultiBitSelBloomFilter.hh deleted file mode 100644 index 58213351a..000000000 --- a/src/mem/ruby/filters/MultiBitSelBloomFilter.hh +++ /dev/null @@ -1,79 +0,0 @@ -/* - * 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. - */ - -#ifndef __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__ - -#include "mem/ruby/filters/AbstractBloomFilter.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 // __MEM_RUBY_FILTERS_MULTIBITSELBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.cc b/src/mem/ruby/filters/MultiGrainBloomFilter.cc deleted file mode 100644 index e5998debe..000000000 --- a/src/mem/ruby/filters/MultiGrainBloomFilter.cc +++ /dev/null @@ -1,118 +0,0 @@ -/* - * 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. - */ - -#include "mem/ruby/filters/MultiGrainBloomFilter.hh" - -#include "base/logging.hh" -#include "params/BloomFilterMultiGrain.hh" - -namespace BloomFilter { - -MultiGrain::MultiGrain(const BloomFilterMultiGrainParams* p) - : Base(p), filters(p->filters) -{ -} - -MultiGrain::~MultiGrain() -{ -} - -void -MultiGrain::clear() -{ - for (auto& sub_filter : filters) { - sub_filter->clear(); - } -} - -void -MultiGrain::merge(const Base* other) -{ - auto* cast_other = static_cast(other); - assert(filters.size() == cast_other->filters.size()); - for (int i = 0; i < filters.size(); ++i){ - filters[i]->merge(cast_other->filters[i]); - } -} - -void -MultiGrain::set(Addr addr) -{ - for (auto& sub_filter : filters) { - sub_filter->set(addr); - } -} - -void -MultiGrain::unset(Addr addr) -{ - for (auto& sub_filter : filters) { - sub_filter->unset(addr); - } -} - -bool -MultiGrain::isSet(Addr addr) const -{ - int count = 0; - for (const auto& sub_filter : filters) { - if (sub_filter->isSet(addr)) { - count++; - } - } - return count >= setThreshold; -} - -int -MultiGrain::getCount(Addr addr) const -{ - int count = 0; - for (const auto& sub_filter : filters) { - count += sub_filter->getCount(addr); - } - return count; -} - -int -MultiGrain::getTotalCount() const -{ - int count = 0; - for (const auto& sub_filter : filters) { - count += sub_filter->getTotalCount(); - } - return count; -} - -} // namespace BloomFilter - -BloomFilter::MultiGrain* -BloomFilterMultiGrainParams::create() -{ - return new BloomFilter::MultiGrain(this); -} - diff --git a/src/mem/ruby/filters/MultiGrainBloomFilter.hh b/src/mem/ruby/filters/MultiGrainBloomFilter.hh deleted file mode 100644 index 3f4a0db66..000000000 --- a/src/mem/ruby/filters/MultiGrainBloomFilter.hh +++ /dev/null @@ -1,67 +0,0 @@ -/* - * 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. - */ - -#ifndef __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__ -#define __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__ - -#include - -#include "mem/ruby/filters/AbstractBloomFilter.hh" - -struct BloomFilterMultiGrainParams; - -namespace BloomFilter { - -/** - * This BloomFilter has multiple sub-filters, each with its own hashing - * functionality. The results of the operations are the results of applying - * them to each sub-filter. - */ -class MultiGrain : public Base -{ - public: - MultiGrain(const BloomFilterMultiGrainParams* p); - ~MultiGrain(); - - 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 filters; -}; - -} // namespace BloomFilter - -#endif // __MEM_RUBY_FILTERS_MULTIGRAINBLOOMFILTER_HH__ diff --git a/src/mem/ruby/filters/SConscript b/src/mem/ruby/filters/SConscript deleted file mode 100644 index 8c7b2a2f8..000000000 --- a/src/mem/ruby/filters/SConscript +++ /dev/null @@ -1,43 +0,0 @@ -# -*- mode:python -*- - -# 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 - -Import('*') - -if env['PROTOCOL'] == 'None': - Return() - -SimObject('BloomFilters.py') - -Source('BlockBloomFilter.cc') -Source('BulkBloomFilter.cc') -Source('H3BloomFilter.cc') -Source('LSB_CountingBloomFilter.cc') -Source('MultiBitSelBloomFilter.cc') -Source('MultiGrainBloomFilter.cc') diff --git a/src/mem/ruby/protocol/RubySlicc_Types.sm b/src/mem/ruby/protocol/RubySlicc_Types.sm index 28fb6ef00..2d4c250da 100644 --- a/src/mem/ruby/protocol/RubySlicc_Types.sm +++ b/src/mem/ruby/protocol/RubySlicc_Types.sm @@ -233,15 +233,6 @@ structure (TimerTable, inport="yes", external = "yes") { bool isSet(Addr); } -structure (AbstractBloomFilter, external = "yes") { - void clear(int); - void set(Addr, int); - void unset(Addr, int); - - bool isSet(Addr, int); - int getCount(Addr, int); -} - structure (Prefetcher, external = "yes") { void observeMiss(Addr, RubyRequestType); void observePfHit(Addr); -- cgit v1.2.3