derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mem-ruby: Move Bloom Filters to base

Browse Source 
All Bloom Filters are completely independent of Ruby, and
therefore can be used everywhere.

As a side effect, Ruby was not using the filters, so
their dependency was removed.

Change-Id: Ic5f430610c33c0791fb81c79101ebe737189497e
Signed-off-by: Daniel R. Carvalho <odanrc@yahoo.com.br>
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/18875
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Maintainer: Jason Lowe-Power <jason@lowepower.com>
This commit is contained in:
Daniel R. Carvalho
2019-05-11 23:19:48 +02:00
committed by Daniel Carvalho
parent 9b9045bb67
commit 8d65e51f7f
17 changed files with 108 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/base/filters/BloomFilters.py Normal file
View File

@@ -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

42
src/base/filters/SConscript Normal file
View File

@@ -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')

151
src/base/filters/base.hh Normal file
View File

@@ -0,0 +1,151 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#ifndef __BASE_FILTERS_BASE_HH__
#define __BASE_FILTERS_BASE_HH__
#include <vector>
#include "base/intmath.hh"
#include "base/types.hh"
#include "params/BloomFilterBase.hh"
#include "sim/sim_object.hh"
namespace BloomFilter {
class Base : public SimObject
{
protected:
/** Number of LSB bits to ignore from the the addresses. */
const unsigned offsetBits;
/** The filter itself. */
std::vector<int> filter;
/** Number of bits needed to represent the size of the filter. */
const int sizeBits;
/** Threshold at which a filter entry starts being considered as set. */
const int setThreshold;
public:
/**
* Create and clear the filter.
*/
Base(const BloomFilterBaseParams* p)
: SimObject(p), offsetBits(p->offset_bits), filter(p->size),
sizeBits(floorLog2(p->size)), setThreshold(p->threshold)
{
clear();
}
virtual ~Base() {};
/**
* Clear the filter by resetting all values.
*/
virtual void clear()
{
for (auto& entry : filter) {
entry = 0;
}
}
/**
* Merges the contents of both filters into this' (Bloom Filter union).
* Both must have the same number of entries.
*
* @param other The other bloom filter to merge with.
*/
virtual void
merge(const Base* other)
{
assert(filter.size() == other->filter.size());
for (int i = 0; i < filter.size(); ++i){
filter[i] |= other->filter[i];
}
}
/**
* Perform the filter specific function to set the corresponding
* entries (can be multiple) of an address.
*
* @param addr The address being parsed.
*/
virtual void set(Addr addr) = 0;
/**
* Perform the filter specific function to clear the corresponding
* entries (can be multiple) of an address. By default a bloom
* filter does not support element deletion.
*
* @param addr The address being parsed.
*/
virtual void unset(Addr addr) {};
/**
* Check if the corresponding filter entries of an address should be
* considered as set.
*
* @param addr The address being parsed.
* @return Whether the respective filter entry is set.
*/
virtual bool
isSet(Addr addr) const
{
return getCount(addr) >= setThreshold;
}
/**
* Get the value stored in the corresponding filter entry of an address.
*
* @param addr The address being parsed.
* @param Get the value stored in the respective filter entry.
*/
virtual int getCount(Addr addr) const { return 0; }
/**
* Get the total value stored in the filter entries.
*
* @return The sum of all filter entries.
*/
virtual int getTotalCount() const
{
int count = 0;
for (const auto& entry : filter) {
count += entry;
}
return count;
}
};
} // namespace BloomFilter
#endif // __BASE_FILTERS_BASE_HH__

101
src/base/filters/block_bloom_filter.cc Normal file
View File

@@ -0,0 +1,101 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#include "base/filters/block_bloom_filter.hh"
#include "base/bitfield.hh"
#include "base/logging.hh"
#include "params/BloomFilterBlock.hh"
namespace BloomFilter {
Block::Block(const BloomFilterBlockParams* p)
: Base(p), masksLSBs(p->masks_lsbs),
masksSizes(p->masks_sizes)
{
fatal_if(masksLSBs.size() != masksSizes.size(),
"Masks haven't been properly provided");
fatal_if(masksLSBs.size() < 1,
"There must be at least one mask to extract an address bitfield");
for (int i = 0; i < masksLSBs.size(); i++) {
fatal_if((masksSizes[i] > sizeBits) || (masksSizes[i] <= 0),
"The bitfields must be indexable in the filter");
fatal_if(masksLSBs[i] + masksSizes[i] >
std::numeric_limits<Addr>::digits,
"The total size of the bitfields cannot be bigger than the " \
"number of bits in an address");
}
}
Block::~Block()
{
}
void
Block::set(Addr addr)
{
filter[hash(addr)] = 1;
}
void
Block::unset(Addr addr)
{
filter[hash(addr)] = 0;
}
int
Block::getCount(Addr addr) const
{
return filter[hash(addr)];
}
int
Block::hash(Addr addr) const
{
Addr hashed_addr = 0;
for (int i = 0; i < masksLSBs.size(); i++) {
hashed_addr ^=
bits(addr, offsetBits + masksLSBs[i] + masksSizes[i] - 1,
offsetBits + masksLSBs[i]);
}
assert(hashed_addr < filter.size());
return hashed_addr;
}
} // namespace BloomFilter
BloomFilter::Block*
BloomFilterBlockParams::create()
{
return new BloomFilter::Block(this);
}

75
src/base/filters/block_bloom_filter.hh Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#ifndef __BASE_FILTERS_BLOCK_BLOOM_FILTER_HH__
#define __BASE_FILTERS_BLOCK_BLOOM_FILTER_HH__
#include <vector>
#include "base/filters/base.hh"
struct BloomFilterBlockParams;
namespace BloomFilter {
/**
* Simple deletable (with false negatives) bloom filter that extracts
* bitfields of an address to use as indexes of the filter vector.
*/
class Block : public Base
{
public:
Block(const BloomFilterBlockParams* p);
~Block();
void set(Addr addr) override;
void unset(Addr addr) override;
int getCount(Addr addr) const override;
private:
/**
* XOR hash between bitfields of an address, provided by the mask vector.
*
* @param addr The address to be hashed.
* @return The value of the XOR of the masked bitfields of the address.
*/
int hash(Addr addr) const;
/** Position of the LSB of each mask. */
std::vector<unsigned> masksLSBs;
/** Number of bits in each mask. */
std::vector<unsigned> masksSizes;
};
} // namespace BloomFilter
#endif // __BASE_FILTERS_BLOCK_BLOOM_FILTER_HH__

169
src/base/filters/bulk_bloom_filter.cc Normal file
View File

@@ -0,0 +1,169 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#include "base/filters/bulk_bloom_filter.hh"
#include <vector>
#include <limits>
#include "base/bitfield.hh"
#include "params/BloomFilterBulk.hh"
namespace BloomFilter {
Bulk::Bulk(const BloomFilterBulkParams* p)
: Base(p), sectorBits(sizeBits - 1)
{
}
Bulk::~Bulk()
{
}
void
Bulk::set(Addr addr)
{
// c0 contains the cache index bits
int c0 = bits(addr, offsetBits + sectorBits - 1, offsetBits);
// c1 contains the lower sectorBits permuted bits
//Address permuted_bits = permute(addr);
int c1 = bits(addr, (offsetBits + 2 * sectorBits) - 1,
offsetBits + sectorBits);
//assert(c0 < (filter_size/2));
//assert(c0 + (filter_size/2) < filter_size);
//assert(c1 < (filter_size/2));
// set v0 bit
filter[c0 + (filter.size()/2)] = 1;
// set v1 bit
filter[c1] = 1;
}
bool
Bulk::isSet(Addr addr) const
{
// c0 contains the cache index bits
const int filter_size = filter.size();
int c0 = bits(addr, offsetBits + sectorBits - 1, offsetBits);
// c1 contains the lower 10 permuted bits
//Address permuted_bits = permute(addr);
int c1 = bits(addr, (offsetBits + 2 * sectorBits) - 1,
offsetBits + sectorBits);
//assert(c0 < (filter_size/2));
//assert(c0 + (filter_size/2) < filter_size);
//assert(c1 < (filter_size/2));
// set v0 bit
std::vector<int> temp_filter(filter.size(), 0);
temp_filter[c0 + (filter_size/2)] = 1;
// set v1 bit
temp_filter[c1] = 1;
// perform filter intersection. If any c part is 0, no possibility
// of address being in signature. get first c intersection part
bool zero = false;
for (int i = 0; i < filter_size/2; ++i){
// get intersection of signatures
temp_filter[i] = temp_filter[i] && filter[i];
zero = zero || temp_filter[i];
}
zero = !zero;
if (zero) {
// one section is zero, no possiblility of address in signature
// reset bits we just set
temp_filter[c0 + (filter_size / 2)] = 0;
temp_filter[c1] = 0;
return false;
}
// check second section
zero = false;
for (int i = filter_size / 2; i < filter_size; ++i) {
// get intersection of signatures
temp_filter[i] = temp_filter[i] && filter[i];
zero = zero || temp_filter[i];
}
zero = !zero;
if (zero) {
// one section is zero, no possiblility of address in signature
temp_filter[c0 + (filter_size / 2)] = 0;
temp_filter[c1] = 0;
return false;
}
// one section has at least one bit set
temp_filter[c0 + (filter_size / 2)] = 0;
temp_filter[c1] = 0;
return true;
}
int
Bulk::getCount(Addr addr) const
{
// TODO as in the multi-hashed filters
return 0;
}
Addr
Bulk::hash(Addr addr) const
{
// permutes the original address bits according to Table 5
Addr part1 = bits(addr, offsetBits + 6, offsetBits),
part2 = bits(addr, offsetBits + 9),
part3 = bits(addr, offsetBits + 11),
part4 = bits(addr, offsetBits + 17),
part5 = bits(addr, offsetBits + 8, offsetBits + 7),
part6 = bits(addr, offsetBits + 10),
part7 = bits(addr, offsetBits + 12),
part8 = bits(addr, offsetBits + 13),
part9 = bits(addr, offsetBits + 16, offsetBits + 15),
part10 = bits(addr, offsetBits + 20, offsetBits + 18),
part11 = bits(addr, offsetBits + 14);
Addr result =
(part1 << 14) | (part2 << 13) | (part3 << 12) | (part4 << 11) |
(part5 << 9) | (part6 << 8) | (part7 << 7) | (part8 << 6) |
(part9 << 4) | (part10 << 1) | (part11);
// Select the remaining high-order bits
Addr remaining_bits = bits(addr, std::numeric_limits<Addr>::digits - 1,
offsetBits + 21) << 21;
result = result | remaining_bits;
return result;
}
} // namespace BloomFilter
BloomFilter::Bulk*
BloomFilterBulkParams::create()
{
return new BloomFilter::Bulk(this);
}

66
src/base/filters/bulk_bloom_filter.hh Normal file
View File

@@ -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__

401
src/base/filters/h3_bloom_filter.cc Normal file
View File

@@ -0,0 +1,401 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#include "base/filters/h3_bloom_filter.hh"
#include <limits>
#include "base/bitfield.hh"
#include "base/logging.hh"
#include "params/BloomFilterH3.hh"
namespace BloomFilter {
static int H3Matrix[64][16] = {
{ 33268410, 395488709, 311024285, 456111753,
181495008, 119997521, 220697869, 433891432,
755927921, 515226970, 719448198, 349842774,
269183649, 463275672, 429800228, 521598937, },
{ 628677802, 820947732, 809435975, 1024657192,
887631270, 412050215, 391365090, 324227279,
318338329, 1038393087, 489807930, 387366128,
518096428, 324184340, 429376066, 447109279, },
{ 599747653, 404960623, 103933604, 946416030,
656460913, 925957005, 1047665689, 163552053,
88359290, 841315415, 899833584, 1067336680,
348549994, 464045876, 270252128, 829897652, },
{ 215495230, 966696438, 82589012, 750102795,
909780866, 920285789, 769759214, 331966823,
939936006, 439950703, 883794828, 1009277508,
61634610, 741444350, 98689608, 524144422, },
{ 93868534, 196958667, 774076619, 327921978,
122538783, 879785030, 690748527, 3498564,
83163077, 1027963025, 582088444, 466152216,
312424878, 550064499, 646612667, 561099434, },
{ 1002047931, 395477707, 821317480, 890482112,
697094476, 263813044, 840275189, 469664185,
795625845, 211504898, 99204277, 1004491153,
725930417, 1064479221, 893834767, 839719181, },
{ 278507126, 985111995, 706462983, 1042178726,
123281719, 963778122, 500881056, 726291104,
134293026, 568379664, 317050609, 533470307,
1022365922, 197645211, 315125721, 634827678, },
{ 219227366, 553960647, 870169525, 322232839,
508322497, 648672696, 249405795, 883596102,
476433133, 541372919, 646647793, 1042679515,
43242483, 600187508, 499866821, 135713210, },
{ 52837162, 96966684, 401840460, 1071661176,
733560065, 150035417, 341319946, 811582750,
636173904, 519054065, 196321433, 1028294565,
882204070, 522965093, 48884074, 117810166, },
{ 650860353, 789534698, 328813544, 473250022,
143128306, 173196006, 846958825, 174632187,
683273509, 405459497, 787235556, 773873501,
240110267, 426797736, 92043842, 711789240, },
{ 586637493, 5059646, 398035664, 6686087,
498300175, 948278148, 681227731, 592751744,
572019677, 558044722, 589368271, 695745538,
1073416749, 529192035, 550984939, 1070620580, },
{ 102904663, 647598516, 758863940, 313426443,
76504114, 1050747783, 708436441, 563815069,
224107668, 875925186, 167675944, 926209739,
279737287, 1040288182, 768184312, 371708956, },
{ 683968868, 1027427757, 180781926, 742898864,
624078545, 645659833, 577225838, 987150210,
723410002, 224013421, 993286634, 33188488,
247264323, 888018697, 38048664, 189037096, },
{ 475612146, 426739285, 873726278, 529192871,
607715202, 388486246, 987001312, 474493980,
259747270, 417465536, 217062395, 392858482,
563810075, 137852805, 1051814153, 72895217, },
{ 71277086, 785496675, 500608842, 89633426,
274085706, 248467935, 838061983, 48106147,
773662506, 49545328, 9071573, 100739031,
602018002, 904371654, 534132064, 332211304, },
{ 401893602, 735125342, 775548339, 210224843,
256081130, 482894412, 350801633, 1035713633,
429458128, 327281409, 739927752, 359327650,
886942880, 847691759, 752417993, 359445596, },
{ 267472014, 1050659620, 1068232362, 1049684368,
17130239, 690524969, 793224378, 14455158,
423092885, 873853424, 430535778, 7867877,
309731959, 370260786, 862353083, 403906850, },
{ 993077283, 218812656, 389234651, 393202875,
413116501, 263300295, 470013158, 592730725,
441847172, 732392823, 407574059, 875664777,
271347307, 792954404, 554774761, 1022424300, },
{ 675919719, 637054073, 784720745, 149714381,
813144874, 502525801, 635436670, 1003196587,
160786091, 947509775, 969788637, 26854073,
257964369, 63898568, 539767732, 772364518, },
{ 943076868, 1021732472, 697575075, 15843624,
617573396, 534113303, 122953324, 964873912,
942995378, 87830944, 1012914818, 455484661,
592160054, 599844284, 810394353, 836812568, },
{ 688992674, 279465370, 731582262, 687883235,
438178468, 80493001, 342701501, 663561405,
23360106, 531315007, 508931618, 36294623,
231216223, 840438413, 255665680, 663205938, },
{ 857265418, 552630887, 8173237, 792122963,
210140052, 823124938, 667709953, 751538219,
991957789, 462064153, 19070176, 726604748,
714567823, 151147895, 1012619677, 697114353, },
{ 467105652, 683256174, 702387467, 28730434,
549942998, 48712701, 960519696, 1008345587,
679267717, 370932249, 880419471, 352141567,
331640403, 598772468, 95160685, 812053015, },
{ 1053491323, 430526562, 1014938507, 109685515,
765949103, 177288303, 1034642653, 485421658,
71850281, 981034542, 61620389, 601367920,
504420930, 220599168, 583051998, 158735752, },
{ 103033901, 522494916, 658494760, 959206022,
931348143, 834510661, 21542994, 189699884,
679327018, 171983002, 96774168, 456133168,
543103352, 923945936, 970074188, 643658485, },
{ 566379913, 805798263, 840662512, 820206124,
796507494, 223712542, 118811519, 662246595,
809326534, 416471323, 748027186, 161169753,
739149488, 276330378, 924837051, 964873733, },
{ 585882743, 135502711, 3386031, 625631285,
1068193307, 270342640, 432739484, 556606453,
826419155, 1038540977, 158000202, 69109538,
207087256, 298111218, 678046259, 184611498, },
{ 305310710, 46237988, 855726974, 735975153,
930663798, 425764232, 104362407, 391371443,
867622101, 71645091, 61824734, 661902640,
293738633, 309416189, 281710675, 879317360, },
{ 398146324, 398293087, 689145387, 1038451703,
521637478, 516134620, 314658937, 830334981,
583400300, 340083705, 68029852, 675389876,
994635780, 788959180, 406967042, 74403607, },
{ 69463153, 744427484, 191639960, 590927798,
969916795, 546846769, 728756758, 889355646,
520855076, 136068426, 776132410, 189663815,
252051082, 533662856, 362198652, 1026161384, },
{ 584984279, 1004834381, 568439705, 834508761,
21812513, 670870173, 1052043300, 341868768,
473755574, 124339439, 36193947, 437997647,
137419489, 58705193, 337793711, 340738909, },
{ 898051466, 512792906, 234874060, 655358775,
683745319, 671676404, 428888546, 639928192,
672697722, 176477579, 747020991, 758211282,
443045009, 205395173, 1016944273, 5584717, },
{ 156038300, 138620174, 588466825, 1061494056,
1013672100, 1064257198, 881417791, 839470738,
83519030, 100875683, 237486447, 461483733,
681527127, 777996147, 574635362, 815974538, },
{ 184168473, 519509808, 62531892, 51821173,
43787358, 385711644, 141325169, 36069511,
584183031, 571372909, 671503175, 226486781,
194932686, 1045460970, 753718579, 331442433, },
{ 73065106, 1015327221, 630916840, 1058053470,
306737587, 296343219, 907194989, 920172546,
224516225, 818625553, 551143849, 634570650,
432966225, 756438259, 939564853, 767999933, },
{ 884775648, 394862257, 446787794, 219833788,
727195727, 728122304, 249888353, 732947974,
289908868, 448282580, 618161877, 898939716,
739554163, 860631799, 1058977530, 86916736, },
{ 143850006, 352708694, 200194048, 979764914,
629404175, 546279766, 72106714, 860980514,
313190585, 897143111, 308425797, 953791785,
349924906, 221457005, 950588925, 908254505, },
{ 950032043, 829868728, 68623614, 714624605,
69760597, 297275854, 355894016, 985369737,
882852618, 864071289, 958512902, 950910111,
991368991, 829645051, 434698210, 771350575, },
{ 552695074, 319195551, 80297396, 496413831,
944046531, 621525571, 617653363, 416729825,
441842808, 9847464, 99420657, 1033914550,
812966458, 937053011, 673390195, 934577365, },
{ 1034695843, 190969665, 332900185, 51897434,
523888639, 883512843, 146908572, 506785674,
565814307, 692255649, 314052926, 826386588,
430691325, 866927620, 413880214, 936474339, },
{ 129380164, 741739952, 1013703462, 494392795,
957214600, 1010879043, 931790677, 94551922,
988065869, 120637871, 882506912, 395075379,
210570485, 812422692, 910383687, 817722285, },
{ 51850866, 283408630, 1053047202, 858940389,
818507731, 477082181, 353546901, 993324368,
407093779, 231608253, 1067319867, 73159811,
429792535, 971320614, 565699344, 718823399, },
{ 408185106, 491493570, 596050720, 310776444,
703628192, 454438809, 523988035, 728512200,
686012353, 976339656, 72816924, 116926720,
165866591, 452043792, 866943072, 968545481, },
{ 443231195, 905907843, 1061421320, 746360489,
1043120338, 1069659155, 463359031, 688303227,
186550710, 155347339, 1044842421, 1005904570,
69332909, 706951903, 422513657, 882038450, },
{ 430990623, 946501980, 742556791, 278398643,
183759217, 659404315, 279754382, 1069347846,
843746517, 222777670, 990835599, 548741637,
129220580, 1392170, 1032654091, 894058935, },
{ 452042227, 751640705, 259481376, 765824585,
145991469, 1013683228, 1055491225, 536379588,
392593350, 913368594, 1029429776, 226857786,
31505342, 1054416381, 32341741, 687106649, },
{ 404750944, 811417027, 869530820, 773491060,
810901282, 979340397, 1036910290, 461764404,
834235095, 765695033, 604692390, 452158120,
928988098, 442719218, 1024059719, 167723114, },
{ 974245177, 1046377300, 1003424287, 787349855,
336314155, 875074696, 1018462718, 890313003,
367376809, 86355556, 1020618772, 890710345,
444741481, 373230261, 767064947, 840920177, },
{ 719581124, 431808156, 138301690, 668222575,
497413494, 740492013, 485033226, 125301442,
831265111, 879071459, 341690480, 152975256,
850330086, 717444507, 694225877, 785340566, },
{ 1032766252, 140959364, 737474726, 1062767538,
364464647, 331414723, 356152634, 642832379,
158733632, 374691640, 285504811, 345349905,
876599880, 476392727, 479589210, 606376325, },
{ 174997730, 778177086, 319164313, 163614456,
10331364, 599358958, 8331663, 237538058,
159173957, 174533880, 65588684, 878222844,
424467599, 901803515, 187504218, 776690353, },
{ 803856182, 965850321, 694948067, 218315960,
358416571, 683713254, 178069303, 428076035,
686176454, 579553217, 357306738, 315018080,
886852373, 568563910, 896839725, 257416821, },
{ 401650013, 183289141, 497957228, 879734476,
265024455, 825794561, 889237440, 323359863,
100258491, 991414783, 313986632, 85847250,
362520248, 276103512, 1041630342, 525981595, },
{ 487732740, 46201705, 990837834, 62744493,
1067364756, 58015363, 690846283, 680262648,
997278956, 469357861, 432164624, 996763915,
211907847, 167824295, 144928194, 454839915, },
{ 41404232, 514493300, 259546924, 578217256,
972345130, 123299213, 346040332, 1014668104,
520910639, 579955198, 36627803, 179072921,
547684341, 598950511, 269497394, 854352266, },
{ 603906768, 100863318, 708837659, 204175569,
375560904, 908375384, 28314106, 6303733,
175283124, 749851198, 308667367, 415293931,
225365403, 1032188331, 977112710, 819705229, },
{ 399767123, 697985692, 356790426, 643687584,
298624218, 185095167, 381653926, 876816342,
296720023, 2205879, 235816616, 521850105,
622753786, 1021421218, 726349744, 256504902, },
{ 851245024, 1022500222, 511909628, 313809625,
99776025, 39710175, 798739932, 741832408,
140631966, 898295927, 607660421, 870669312,
1051422478, 789055529, 669113756, 681943450, },
{ 853872755, 491465269, 503341472, 98019440,
258267420, 335602837, 320687824, 1053324395,
24932389, 955011453, 934255131, 435625663,
501568768, 238967025, 549987406, 248619780, },
{ 411151284, 576471205, 757985419, 544137226,
968135693, 877548443, 194586894, 74882373,
248353663, 21207540, 273789651, 853653916,
861267970, 533253322, 3739570, 661358586, },
{ 271430986, 71390029, 257643671, 949329860,
348156406, 251939238, 445808698, 48269799,
907589462, 105677619, 635451508, 20805932,
464874661, 7542147, 243619464, 288304568, },
{ 368215982, 530288964, 770090421, 660961164,
614935537, 630760399, 931299233, 794519275,
779918979, 401746493, 561237006, 1027202224,
258968003, 339508073, 1050610516, 1064307013, },
{ 1039172162, 448331205, 928997884, 49813151,
198712120, 992335354, 671024050, 879525220,
745915336, 1038822580, 138669665, 917958819,
681422342, 792868818, 924762727, 816386174, },
{ 515190336, 313808618, 441296783, 1022120897,
792325033, 354387581, 59273006, 280075434,
411357221, 665274694, 4054464, 1059046246,
394261773, 848616745, 15446017, 517723271, },
};
H3::H3(const BloomFilterH3Params* p)
: MultiBitSel(p)
{
fatal_if(numHashes > 16, "There are only 16 H3 functions implemented.");
}
H3::~H3()
{
}
int
H3::hash(Addr addr, int hash_number) const
{
uint64_t val =
bits(addr, std::numeric_limits<Addr>::digits - 1, offsetBits);
int result = 0;
for (int i = 0; (i < 64) && val; i++, val >>= 1) {
if (val & 1) {
result ^= H3Matrix[i][hash_number];
}
}
if (isParallel) {
return (result % parFilterSize) + hash_number * parFilterSize;
} else {
return result % filter.size();
}
}
} // namespace BloomFilter
BloomFilter::H3*
BloomFilterH3Params::create()
{
return new BloomFilter::H3(this);
}

57
src/base/filters/h3_bloom_filter.hh Normal file
View File

@@ -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__

98
src/base/filters/lsb_counting_bloom_filter.cc Normal file
View File

@@ -0,0 +1,98 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#include "base/filters/lsb_counting_bloom_filter.hh"
#include "base/bitfield.hh"
#include "params/BloomFilterLSBCounting.hh"
namespace BloomFilter {
LSBCounting::LSBCounting(
const BloomFilterLSBCountingParams* p)
: Base(p), maxValue(p->max_value)
{
}
LSBCounting::~LSBCounting()
{
}
void
LSBCounting::merge(const Base* other)
{
auto* cast_other = static_cast<const LSBCounting*>(other);
assert(filter.size() == cast_other->filter.size());
for (int i = 0; i < filter.size(); ++i){
if (filter[i] < maxValue - cast_other->filter[i]) {
filter[i] += cast_other->filter[i];
} else {
filter[i] = maxValue;
}
}
}
void
LSBCounting::set(Addr addr)
{
const int i = hash(addr);
if (filter[i] < maxValue)
filter[i] += 1;
}
void
LSBCounting::unset(Addr addr)
{
const int i = hash(addr);
if (filter[i] > 0)
filter[i] -= 1;
}
int
LSBCounting::getCount(Addr addr) const
{
return filter[hash(addr)];
}
int
LSBCounting::hash(Addr addr) const
{
return bits(addr, offsetBits + sizeBits - 1, offsetBits);
}
} // namespace BloomFilter
BloomFilter::LSBCounting*
BloomFilterLSBCountingParams::create()
{
return new BloomFilter::LSBCounting(this);
}

62
src/base/filters/lsb_counting_bloom_filter.hh Normal file
View File

@@ -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__

106
src/base/filters/multi_bit_sel_bloom_filter.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#include "base/filters/multi_bit_sel_bloom_filter.hh"
#include <limits>
#include "base/bitfield.hh"
#include "base/logging.hh"
#include "params/BloomFilterMultiBitSel.hh"
namespace BloomFilter {
MultiBitSel::MultiBitSel(const BloomFilterMultiBitSelParams* p)
: Base(p), numHashes(p->num_hashes),
parFilterSize(p->size / numHashes),
isParallel(p->is_parallel), skipBits(p->skip_bits)
{
if (p->size % numHashes) {
fatal("Can't divide filter (%d) in %d equal portions", p->size,
numHashes);
}
}
MultiBitSel::~MultiBitSel()
{
}
void
MultiBitSel::set(Addr addr)
{
for (int i = 0; i < numHashes; i++) {
int idx = hash(addr, i);
filter[idx] = 1;
}
}
int
MultiBitSel::getCount(Addr addr) const
{
int count = 0;
for (int i=0; i < numHashes; i++) {
count += filter[hash(addr, i)];
}
return count;
}
int
MultiBitSel::hash(Addr addr, int hash_number) const
{
uint64_t value = bits(addr, std::numeric_limits<Addr>::digits - 1,
offsetBits) >> skipBits;
const int max_bits = std::numeric_limits<Addr>::digits - offsetBits;
int result = 0;
int bit, i;
for (i = 0; i < sizeBits; i++) {
bit = (hash_number + numHashes * i) % max_bits;
if (value & (1 << bit)) {
result += 1 << i;
}
}
if (isParallel) {
return (result % parFilterSize) + hash_number * parFilterSize;
} else {
return result % filter.size();
}
}
} // namespace BloomFilter
BloomFilter::MultiBitSel*
BloomFilterMultiBitSelParams::create()
{
return new BloomFilter::MultiBitSel(this);
}

82
src/base/filters/multi_bit_sel_bloom_filter.hh Normal file
View File

@@ -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__

121
src/base/filters/multi_bloom_filter.cc Normal file
View File

@@ -0,0 +1,121 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#include "base/filters/multi_bloom_filter.hh"
#include "base/logging.hh"
#include "params/BloomFilterMulti.hh"
namespace BloomFilter {
Multi::Multi(const BloomFilterMultiParams* p)
: Base(p), filters(p->filters)
{
}
Multi::~Multi()
{
}
void
Multi::clear()
{
for (auto& sub_filter : filters) {
sub_filter->clear();
}
}
void
Multi::merge(const Base* other)
{
auto* cast_other = static_cast<const Multi*>(other);
assert(filters.size() == cast_other->filters.size());
for (int i = 0; i < filters.size(); ++i){
filters[i]->merge(cast_other->filters[i]);
}
}
void
Multi::set(Addr addr)
{
for (auto& sub_filter : filters) {
sub_filter->set(addr);
}
}
void
Multi::unset(Addr addr)
{
for (auto& sub_filter : filters) {
sub_filter->unset(addr);
}
}
bool
Multi::isSet(Addr addr) const
{
int count = 0;
for (const auto& sub_filter : filters) {
if (sub_filter->isSet(addr)) {
count++;
}
}
return count >= setThreshold;
}
int
Multi::getCount(Addr addr) const
{
int count = 0;
for (const auto& sub_filter : filters) {
count += sub_filter->getCount(addr);
}
return count;
}
int
Multi::getTotalCount() const
{
int count = 0;
for (const auto& sub_filter : filters) {
count += sub_filter->getTotalCount();
}
return count;
}
} // namespace BloomFilter
BloomFilter::Multi*
BloomFilterMultiParams::create()
{
return new BloomFilter::Multi(this);
}

70
src/base/filters/multi_bloom_filter.hh Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright (c) 2019 Inria
* Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Daniel Carvalho
*/
#ifndef __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__
#define __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__
#include <vector>
#include "base/filters/base.hh"
struct BloomFilterMultiParams;
namespace BloomFilter {
/**
* This BloomFilter has multiple sub-filters, each with its own hashing
* functionality. The results of the operations are the results of applying
* them to each sub-filter.
*/
class Multi : public Base
{
public:
Multi(const BloomFilterMultiParams* p);
~Multi();
void clear() override;
void set(Addr addr) override;
void unset(Addr addr) override;
void merge(const Base* other) override;
bool isSet(Addr addr) const override;
int getCount(Addr addr) const override;
int getTotalCount() const override;
private:
/** Sub-filters used by this filter. */
std::vector<Base*> filters;
};
} // namespace BloomFilter
#endif // __BASE_FILTERS_MULTI_BLOOM_FILTER_HH__