Browse Source
common: Remove bit_set.h
common: Remove bit_set.h
This is an analog of BitSet from Dolphin that was introduced to allow iterating over a set of bits. Given it's currently unused, and given that std::bitset exists, we can remove this. If it's ever needed in the future it can be brought back.nce_cpp
Lioncash
7 years ago
2 changed files with 0 additions and 245 deletions
@ -1,244 +0,0 @@ |
|||
// This file is under the public domain. |
|||
|
|||
#pragma once |
|||
|
|||
#include <cstddef> |
|||
#ifdef _WIN32 |
|||
#include <intrin.h> |
|||
#endif |
|||
#include <initializer_list> |
|||
#include <new> |
|||
#include <type_traits> |
|||
#include "common/common_types.h" |
|||
|
|||
// namespace avoids conflict with OS X Carbon; don't use BitSet<T> directly |
|||
namespace Common { |
|||
|
|||
// Helper functions: |
|||
|
|||
#ifdef _MSC_VER |
|||
template <typename T> |
|||
static inline int CountSetBits(T v) { |
|||
// from https://graphics.stanford.edu/~seander/bithacks.html |
|||
// GCC has this built in, but MSVC's intrinsic will only emit the actual |
|||
// POPCNT instruction, which we're not depending on |
|||
v = v - ((v >> 1) & (T) ~(T)0 / 3); |
|||
v = (v & (T) ~(T)0 / 15 * 3) + ((v >> 2) & (T) ~(T)0 / 15 * 3); |
|||
v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15; |
|||
return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8; |
|||
} |
|||
static inline int LeastSignificantSetBit(u8 val) { |
|||
unsigned long index; |
|||
_BitScanForward(&index, val); |
|||
return (int)index; |
|||
} |
|||
static inline int LeastSignificantSetBit(u16 val) { |
|||
unsigned long index; |
|||
_BitScanForward(&index, val); |
|||
return (int)index; |
|||
} |
|||
static inline int LeastSignificantSetBit(u32 val) { |
|||
unsigned long index; |
|||
_BitScanForward(&index, val); |
|||
return (int)index; |
|||
} |
|||
static inline int LeastSignificantSetBit(u64 val) { |
|||
unsigned long index; |
|||
_BitScanForward64(&index, val); |
|||
return (int)index; |
|||
} |
|||
#else |
|||
static inline int CountSetBits(u8 val) { |
|||
return __builtin_popcount(val); |
|||
} |
|||
static inline int CountSetBits(u16 val) { |
|||
return __builtin_popcount(val); |
|||
} |
|||
static inline int CountSetBits(u32 val) { |
|||
return __builtin_popcount(val); |
|||
} |
|||
static inline int CountSetBits(u64 val) { |
|||
return __builtin_popcountll(val); |
|||
} |
|||
static inline int LeastSignificantSetBit(u8 val) { |
|||
return __builtin_ctz(val); |
|||
} |
|||
static inline int LeastSignificantSetBit(u16 val) { |
|||
return __builtin_ctz(val); |
|||
} |
|||
static inline int LeastSignificantSetBit(u32 val) { |
|||
return __builtin_ctz(val); |
|||
} |
|||
static inline int LeastSignificantSetBit(u64 val) { |
|||
return __builtin_ctzll(val); |
|||
} |
|||
#endif |
|||
|
|||
// Similar to std::bitset, this is a class which encapsulates a bitset, i.e. |
|||
// using the set bits of an integer to represent a set of integers. Like that |
|||
// class, it acts like an array of bools: |
|||
// BitSet32 bs; |
|||
// bs[1] = true; |
|||
// but also like the underlying integer ([0] = least significant bit): |
|||
// BitSet32 bs2 = ...; |
|||
// bs = (bs ^ bs2) & BitSet32(0xffff); |
|||
// The following additional functionality is provided: |
|||
// - Construction using an initializer list. |
|||
// BitSet bs { 1, 2, 4, 8 }; |
|||
// - Efficiently iterating through the set bits: |
|||
// for (int i : bs) |
|||
// [i is the *index* of a set bit] |
|||
// (This uses the appropriate CPU instruction to find the next set bit in one |
|||
// operation.) |
|||
// - Counting set bits using .Count() - see comment on that method. |
|||
|
|||
// TODO: use constexpr when MSVC gets out of the Dark Ages |
|||
|
|||
template <typename IntTy> |
|||
class BitSet { |
|||
static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types"); |
|||
|
|||
public: |
|||
// A reference to a particular bit, returned from operator[]. |
|||
class Ref { |
|||
public: |
|||
Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {} |
|||
Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {} |
|||
operator bool() const { |
|||
return (m_bs->m_val & m_mask) != 0; |
|||
} |
|||
bool operator=(bool set) { |
|||
m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0); |
|||
return set; |
|||
} |
|||
|
|||
private: |
|||
BitSet* m_bs; |
|||
IntTy m_mask; |
|||
}; |
|||
|
|||
// A STL-like iterator is required to be able to use range-based for loops. |
|||
class Iterator { |
|||
public: |
|||
Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {} |
|||
Iterator(IntTy val) : m_val(val), m_bit(0) {} |
|||
Iterator& operator=(Iterator other) { |
|||
new (this) Iterator(other); |
|||
return *this; |
|||
} |
|||
int operator*() { |
|||
return m_bit + ComputeLsb(); |
|||
} |
|||
Iterator& operator++() { |
|||
int lsb = ComputeLsb(); |
|||
m_val >>= lsb + 1; |
|||
m_bit += lsb + 1; |
|||
m_has_lsb = false; |
|||
return *this; |
|||
} |
|||
Iterator operator++(int _) { |
|||
Iterator other(*this); |
|||
++*this; |
|||
return other; |
|||
} |
|||
bool operator==(Iterator other) const { |
|||
return m_val == other.m_val; |
|||
} |
|||
bool operator!=(Iterator other) const { |
|||
return m_val != other.m_val; |
|||
} |
|||
|
|||
private: |
|||
int ComputeLsb() { |
|||
if (!m_has_lsb) { |
|||
m_lsb = LeastSignificantSetBit(m_val); |
|||
m_has_lsb = true; |
|||
} |
|||
return m_lsb; |
|||
} |
|||
IntTy m_val; |
|||
int m_bit; |
|||
int m_lsb = -1; |
|||
bool m_has_lsb = false; |
|||
}; |
|||
|
|||
BitSet() : m_val(0) {} |
|||
explicit BitSet(IntTy val) : m_val(val) {} |
|||
BitSet(std::initializer_list<int> init) { |
|||
m_val = 0; |
|||
for (int bit : init) |
|||
m_val |= (IntTy)1 << bit; |
|||
} |
|||
|
|||
static BitSet AllTrue(std::size_t count) { |
|||
return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1)); |
|||
} |
|||
|
|||
Ref operator[](std::size_t bit) { |
|||
return Ref(this, (IntTy)1 << bit); |
|||
} |
|||
const Ref operator[](std::size_t bit) const { |
|||
return (*const_cast<BitSet*>(this))[bit]; |
|||
} |
|||
bool operator==(BitSet other) const { |
|||
return m_val == other.m_val; |
|||
} |
|||
bool operator!=(BitSet other) const { |
|||
return m_val != other.m_val; |
|||
} |
|||
bool operator<(BitSet other) const { |
|||
return m_val < other.m_val; |
|||
} |
|||
bool operator>(BitSet other) const { |
|||
return m_val > other.m_val; |
|||
} |
|||
BitSet operator|(BitSet other) const { |
|||
return BitSet(m_val | other.m_val); |
|||
} |
|||
BitSet operator&(BitSet other) const { |
|||
return BitSet(m_val & other.m_val); |
|||
} |
|||
BitSet operator^(BitSet other) const { |
|||
return BitSet(m_val ^ other.m_val); |
|||
} |
|||
BitSet operator~() const { |
|||
return BitSet(~m_val); |
|||
} |
|||
BitSet& operator|=(BitSet other) { |
|||
return *this = *this | other; |
|||
} |
|||
BitSet& operator&=(BitSet other) { |
|||
return *this = *this & other; |
|||
} |
|||
BitSet& operator^=(BitSet other) { |
|||
return *this = *this ^ other; |
|||
} |
|||
operator u32() = delete; |
|||
operator bool() { |
|||
return m_val != 0; |
|||
} |
|||
|
|||
// Warning: Even though on modern CPUs this is a single fast instruction, |
|||
// Dolphin's official builds do not currently assume POPCNT support on x86, |
|||
// so slower explicit bit twiddling is generated. Still should generally |
|||
// be faster than a loop. |
|||
unsigned int Count() const { |
|||
return CountSetBits(m_val); |
|||
} |
|||
|
|||
Iterator begin() const { |
|||
return Iterator(m_val); |
|||
} |
|||
Iterator end() const { |
|||
return Iterator(0); |
|||
} |
|||
|
|||
IntTy m_val; |
|||
}; |
|||
|
|||
} // namespace Common |
|||
|
|||
typedef Common::BitSet<u8> BitSet8; |
|||
typedef Common::BitSet<u16> BitSet16; |
|||
typedef Common::BitSet<u32> BitSet32; |
|||
typedef Common::BitSet<u64> BitSet64; |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue