Skip to content

A
angle
Commit 8b624c6d by Shahbaz Youssefi Committed by Commit Bot
Options

Use constexpr initializer list for bitsets

Allows setting/resetting multiple bits to be coalesced into one operation. Bug: angleproject:5528 Change-Id: Ibf2dff8c81441a75c268d95066d23da1b2a3c810 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2678885 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: 's avatarTim Van Patten <timvp@google.com> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org>
parent cf8c71de
Showing with 123 additions and 106 deletions
src/common/bitset_utils.h
...@@ -87,60 +87,61 @@ class BitSetT final ...@@ -87,60 +87,61 @@ class BitSetT final
using value_type = BitsT; using value_type = BitsT;
BitSetT(); constexpr BitSetT();
constexpr explicit BitSetT(BitsT value); constexpr explicit BitSetT(BitsT value);
constexpr explicit BitSetT(std::initializer_list<ParamT> init);
BitSetT(const BitSetT &other); constexpr BitSetT(const BitSetT &other);
BitSetT &operator=(const BitSetT &other); constexpr BitSetT &operator=(const BitSetT &other);
bool operator==(const BitSetT &other) const; constexpr bool operator==(const BitSetT &other) const;
bool operator!=(const BitSetT &other) const; constexpr bool operator!=(const BitSetT &other) const;
constexpr bool operator[](ParamT pos) const; constexpr bool operator[](ParamT pos) const;
Reference operator[](ParamT pos) { return Reference(this, pos); } Reference operator[](ParamT pos) { return Reference(this, pos); }
bool test(ParamT pos) const; constexpr bool test(ParamT pos) const;
bool all() const; constexpr bool all() const;
bool any() const; constexpr bool any() const;
bool none() const; constexpr bool none() const;
std::size_t count() const; constexpr std::size_t count() const;
constexpr std::size_t size() const { return N; } constexpr std::size_t size() const { return N; }
BitSetT &operator&=(const BitSetT &other); constexpr BitSetT &operator&=(const BitSetT &other);
BitSetT &operator|=(const BitSetT &other); constexpr BitSetT &operator|=(const BitSetT &other);
BitSetT &operator^=(const BitSetT &other); constexpr BitSetT &operator^=(const BitSetT &other);
BitSetT operator~() const; constexpr BitSetT operator~() const;
BitSetT &operator&=(BitsT value); constexpr BitSetT &operator&=(BitsT value);
BitSetT &operator|=(BitsT value); constexpr BitSetT &operator|=(BitsT value);
BitSetT &operator^=(BitsT value); constexpr BitSetT &operator^=(BitsT value);
BitSetT operator<<(std::size_t pos) const; constexpr BitSetT operator<<(std::size_t pos) const;
BitSetT &operator<<=(std::size_t pos); constexpr BitSetT &operator<<=(std::size_t pos);
BitSetT operator>>(std::size_t pos) const; constexpr BitSetT operator>>(std::size_t pos) const;
BitSetT &operator>>=(std::size_t pos); constexpr BitSetT &operator>>=(std::size_t pos);
BitSetT &set(); constexpr BitSetT &set();
BitSetT &set(ParamT pos, bool value = true); constexpr BitSetT &set(ParamT pos, bool value = true);
BitSetT &reset(); constexpr BitSetT &reset();
BitSetT &reset(ParamT pos); constexpr BitSetT &reset(ParamT pos);
BitSetT &flip(); constexpr BitSetT &flip();
BitSetT &flip(ParamT pos); constexpr BitSetT &flip(ParamT pos);
unsigned long to_ulong() const { return static_cast<unsigned long>(mBits); } constexpr unsigned long to_ulong() const { return static_cast<unsigned long>(mBits); }
BitsT bits() const { return mBits; } constexpr BitsT bits() const { return mBits; }
Iterator begin() const { return Iterator(*this); } Iterator begin() const { return Iterator(*this); }
Iterator end() const { return Iterator(BitSetT()); } Iterator end() const { return Iterator(BitSetT()); }
constexpr static BitSetT Zero() { return BitSetT(); } constexpr static BitSetT Zero() { return BitSetT(); }
ParamT first() const; constexpr ParamT first() const;
ParamT last() const; constexpr ParamT last() const;
// Produces a mask of ones up to the "x"th bit. // Produces a mask of ones up to the "x"th bit.
constexpr static BitsT Mask(std::size_t x) constexpr static BitsT Mask(std::size_t x)
...@@ -156,8 +157,9 @@ template <size_t N> ...@@ -156,8 +157,9 @@ template <size_t N>
class IterableBitSet : public std::bitset<N> class IterableBitSet : public std::bitset<N>
{ {
public: public:
IterableBitSet() {} constexpr IterableBitSet() {}
IterableBitSet(const std::bitset<N> &implicitBitSet) : std::bitset<N>(implicitBitSet) {} constexpr IterableBitSet(const std::bitset<N> &implicitBitSet) : std::bitset<N>(implicitBitSet)
{}
class Iterator final class Iterator final
{ {
...@@ -252,7 +254,7 @@ unsigned long IterableBitSet<N>::Iterator::getNextBit() ...@@ -252,7 +254,7 @@ unsigned long IterableBitSet<N>::Iterator::getNextBit()
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT>::BitSetT() : mBits(0) constexpr BitSetT<N, BitsT, ParamT>::BitSetT() : mBits(0)
{ {
static_assert(N > 0, "Bitset type cannot support zero bits."); static_assert(N > 0, "Bitset type cannot support zero bits.");
static_assert(N <= sizeof(BitsT) * 8, "Bitset type cannot support a size this large."); static_assert(N <= sizeof(BitsT) * 8, "Bitset type cannot support a size this large.");
...@@ -263,24 +265,33 @@ constexpr BitSetT<N, BitsT, ParamT>::BitSetT(BitsT value) : mBits(value & Mask(N ...@@ -263,24 +265,33 @@ constexpr BitSetT<N, BitsT, ParamT>::BitSetT(BitsT value) : mBits(value & Mask(N
{} {}
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT>::BitSetT(const BitSetT &other) : mBits(other.mBits) constexpr BitSetT<N, BitsT, ParamT>::BitSetT(std::initializer_list<ParamT> init) : mBits(0)
{
for (ParamT element : init)
{
mBits |= Bit<BitsT>(element) & Mask(N);
}
}
template <size_t N, typename BitsT, typename ParamT>
constexpr BitSetT<N, BitsT, ParamT>::BitSetT(const BitSetT &other) : mBits(other.mBits)
{} {}
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator=(const BitSetT &other) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator=(const BitSetT &other)
{ {
mBits = other.mBits; mBits = other.mBits;
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
bool BitSetT<N, BitsT, ParamT>::operator==(const BitSetT &other) const constexpr bool BitSetT<N, BitsT, ParamT>::operator==(const BitSetT &other) const
{ {
return mBits == other.mBits; return mBits == other.mBits;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
bool BitSetT<N, BitsT, ParamT>::operator!=(const BitSetT &other) const constexpr bool BitSetT<N, BitsT, ParamT>::operator!=(const BitSetT &other) const
{ {
return mBits != other.mBits; return mBits != other.mBits;
} }
...@@ -292,114 +303,114 @@ constexpr bool BitSetT<N, BitsT, ParamT>::operator[](ParamT pos) const ...@@ -292,114 +303,114 @@ constexpr bool BitSetT<N, BitsT, ParamT>::operator[](ParamT pos) const
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
bool BitSetT<N, BitsT, ParamT>::test(ParamT pos) const constexpr bool BitSetT<N, BitsT, ParamT>::test(ParamT pos) const
{ {
return (mBits & Bit<BitsT>(pos)) != 0; return (mBits & Bit<BitsT>(pos)) != 0;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
bool BitSetT<N, BitsT, ParamT>::all() const constexpr bool BitSetT<N, BitsT, ParamT>::all() const
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
return mBits == Mask(N); return mBits == Mask(N);
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
bool BitSetT<N, BitsT, ParamT>::any() const constexpr bool BitSetT<N, BitsT, ParamT>::any() const
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
return (mBits != 0); return (mBits != 0);
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
bool BitSetT<N, BitsT, ParamT>::none() const constexpr bool BitSetT<N, BitsT, ParamT>::none() const
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
return (mBits == 0); return (mBits == 0);
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
std::size_t BitSetT<N, BitsT, ParamT>::count() const constexpr std::size_t BitSetT<N, BitsT, ParamT>::count() const
{ {
return gl::BitCount(mBits); return gl::BitCount(mBits);
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator&=(const BitSetT &other) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator&=(const BitSetT &other)
{ {
mBits &= other.mBits; mBits &= other.mBits;
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator|=(const BitSetT &other) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator|=(const BitSetT &other)
{ {
mBits |= other.mBits; mBits |= other.mBits;
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator^=(const BitSetT &other) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator^=(const BitSetT &other)
{ {
mBits = mBits ^ other.mBits; mBits = mBits ^ other.mBits;
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> BitSetT<N, BitsT, ParamT>::operator~() const constexpr BitSetT<N, BitsT, ParamT> BitSetT<N, BitsT, ParamT>::operator~() const
{ {
return BitSetT<N, BitsT, ParamT>(~mBits & Mask(N)); return BitSetT<N, BitsT, ParamT>(~mBits & Mask(N));
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator&=(BitsT value) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator&=(BitsT value)
{ {
mBits &= value; mBits &= value;
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator|=(BitsT value) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator|=(BitsT value)
{ {
mBits |= value & Mask(N); mBits |= value & Mask(N);
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator^=(BitsT value) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator^=(BitsT value)
{ {
mBits ^= value & Mask(N); mBits ^= value & Mask(N);
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> BitSetT<N, BitsT, ParamT>::operator<<(std::size_t pos) const constexpr BitSetT<N, BitsT, ParamT> BitSetT<N, BitsT, ParamT>::operator<<(std::size_t pos) const
{ {
return BitSetT<N, BitsT, ParamT>((mBits << pos) & Mask(N)); return BitSetT<N, BitsT, ParamT>((mBits << pos) & Mask(N));
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator<<=(std::size_t pos) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator<<=(std::size_t pos)
{ {
mBits = (mBits << pos & Mask(N)); mBits = (mBits << pos & Mask(N));
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> BitSetT<N, BitsT, ParamT>::operator>>(std::size_t pos) const constexpr BitSetT<N, BitsT, ParamT> BitSetT<N, BitsT, ParamT>::operator>>(std::size_t pos) const
{ {
return BitSetT<N, BitsT, ParamT>(mBits >> pos); return BitSetT<N, BitsT, ParamT>(mBits >> pos);
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator>>=(std::size_t pos) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::operator>>=(std::size_t pos)
{ {
mBits = ((mBits >> pos) & Mask(N)); mBits = ((mBits >> pos) & Mask(N));
return *this; return *this;
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set() constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set()
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
mBits = Mask(N); mBits = Mask(N);
...@@ -407,7 +418,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set() ...@@ -407,7 +418,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set()
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set(ParamT pos, bool value) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set(ParamT pos, bool value)
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
if (value) if (value)
...@@ -422,7 +433,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set(ParamT pos, bool value ...@@ -422,7 +433,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::set(ParamT pos, bool value
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset() constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset()
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
mBits = 0; mBits = 0;
...@@ -430,7 +441,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset() ...@@ -430,7 +441,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset()
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset(ParamT pos) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset(ParamT pos)
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
mBits &= ~Bit<BitsT>(pos); mBits &= ~Bit<BitsT>(pos);
...@@ -438,7 +449,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset(ParamT pos) ...@@ -438,7 +449,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::reset(ParamT pos)
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip() constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip()
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
mBits ^= Mask(N); mBits ^= Mask(N);
...@@ -446,7 +457,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip() ...@@ -446,7 +457,7 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip()
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip(ParamT pos) constexpr BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip(ParamT pos)
{ {
ASSERT(mBits == (mBits & Mask(N))); ASSERT(mBits == (mBits & Mask(N)));
mBits ^= Bit<BitsT>(pos) & Mask(N); mBits ^= Bit<BitsT>(pos) & Mask(N);
...@@ -454,14 +465,14 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip(ParamT pos) ...@@ -454,14 +465,14 @@ BitSetT<N, BitsT, ParamT> &BitSetT<N, BitsT, ParamT>::flip(ParamT pos)
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
ParamT BitSetT<N, BitsT, ParamT>::first() const constexpr ParamT BitSetT<N, BitsT, ParamT>::first() const
{ {
ASSERT(!none()); ASSERT(!none());
return static_cast<ParamT>(gl::ScanForward(mBits)); return static_cast<ParamT>(gl::ScanForward(mBits));
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
ParamT BitSetT<N, BitsT, ParamT>::last() const constexpr ParamT BitSetT<N, BitsT, ParamT>::last() const
{ {
ASSERT(!none()); ASSERT(!none());
return static_cast<ParamT>(gl::ScanReverse(mBits)); return static_cast<ParamT>(gl::ScanReverse(mBits));
...@@ -859,8 +870,9 @@ BitSetArray<N> &BitSetArray<N>::flip() ...@@ -859,8 +870,9 @@ BitSetArray<N> &BitSetArray<N>::flip()
} // namespace angle } // namespace angle
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
inline angle::BitSetT<N, BitsT, ParamT> operator&(const angle::BitSetT<N, BitsT, ParamT> &lhs, inline constexpr angle::BitSetT<N, BitsT, ParamT> operator&(
const angle::BitSetT<N, BitsT, ParamT> &rhs) const angle::BitSetT<N, BitsT, ParamT> &lhs,
const angle::BitSetT<N, BitsT, ParamT> &rhs)
{ {
angle::BitSetT<N, BitsT, ParamT> result(lhs); angle::BitSetT<N, BitsT, ParamT> result(lhs);
result &= rhs.bits(); result &= rhs.bits();
...@@ -868,8 +880,9 @@ inline angle::BitSetT<N, BitsT, ParamT> operator&(const angle::BitSetT<N, BitsT, ...@@ -868,8 +880,9 @@ inline angle::BitSetT<N, BitsT, ParamT> operator&(const angle::BitSetT<N, BitsT,
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
inline angle::BitSetT<N, BitsT, ParamT> operator|(const angle::BitSetT<N, BitsT, ParamT> &lhs, inline constexpr angle::BitSetT<N, BitsT, ParamT> operator|(
const angle::BitSetT<N, BitsT, ParamT> &rhs) const angle::BitSetT<N, BitsT, ParamT> &lhs,
const angle::BitSetT<N, BitsT, ParamT> &rhs)
{ {
angle::BitSetT<N, BitsT, ParamT> result(lhs); angle::BitSetT<N, BitsT, ParamT> result(lhs);
result |= rhs.bits(); result |= rhs.bits();
...@@ -877,8 +890,9 @@ inline angle::BitSetT<N, BitsT, ParamT> operator|(const angle::BitSetT<N, BitsT, ...@@ -877,8 +890,9 @@ inline angle::BitSetT<N, BitsT, ParamT> operator|(const angle::BitSetT<N, BitsT,
} }
template <size_t N, typename BitsT, typename ParamT> template <size_t N, typename BitsT, typename ParamT>
inline angle::BitSetT<N, BitsT, ParamT> operator^(const angle::BitSetT<N, BitsT, ParamT> &lhs, inline constexpr angle::BitSetT<N, BitsT, ParamT> operator^(
const angle::BitSetT<N, BitsT, ParamT> &rhs) const angle::BitSetT<N, BitsT, ParamT> &lhs,
const angle::BitSetT<N, BitsT, ParamT> &rhs)
{ {
angle::BitSetT<N, BitsT, ParamT> result(lhs); angle::BitSetT<N, BitsT, ParamT> result(lhs);
result ^= rhs.bits(); result ^= rhs.bits();
......
src/libANGLE/renderer/vulkan/ContextVk.cpp
...@@ -290,6 +290,14 @@ egl::ContextPriority GetContextPriority(const gl::State &state) ...@@ -290,6 +290,14 @@ egl::ContextPriority GetContextPriority(const gl::State &state)
} }
} // anonymous namespace } // anonymous namespace
// Not necessary once upgraded to C++17.
constexpr ContextVk::DirtyBits ContextVk::kIndexAndVertexDirtyBits;
constexpr ContextVk::DirtyBits ContextVk::kPipelineDescAndBindingDirtyBits;
constexpr ContextVk::DirtyBits ContextVk::kTexturesAndDescSetDirtyBits;
constexpr ContextVk::DirtyBits ContextVk::kResourcesAndDescSetDirtyBits;
constexpr ContextVk::DirtyBits ContextVk::kXfbBuffersAndDescSetDirtyBits;
constexpr ContextVk::DirtyBits ContextVk::kDriverUniformsAndBindingDirtyBits;
ANGLE_INLINE void ContextVk::flushDescriptorSetUpdates() ANGLE_INLINE void ContextVk::flushDescriptorSetUpdates()
{ {
if (mWriteDescriptorSets.empty()) if (mWriteDescriptorSets.empty())
...@@ -408,24 +416,18 @@ ContextVk::ContextVk(const gl::State &state, gl::ErrorSet *errorSet, RendererVk ...@@ -408,24 +416,18 @@ ContextVk::ContextVk(const gl::State &state, gl::ErrorSet *errorSet, RendererVk
// Note that currently these dirty bits are set every time a new render pass command buffer is // Note that currently these dirty bits are set every time a new render pass command buffer is
// begun. However, using ANGLE's SecondaryCommandBuffer, the Vulkan command buffer (which is // begun. However, using ANGLE's SecondaryCommandBuffer, the Vulkan command buffer (which is
// the primary command buffer) is not ended, so technically we don't need to rebind these. // the primary command buffer) is not ended, so technically we don't need to rebind these.
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_RENDER_PASS); mNewGraphicsCommandBufferDirtyBits = DirtyBits{
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_PIPELINE_BINDING); DIRTY_BIT_RENDER_PASS, DIRTY_BIT_PIPELINE_BINDING, DIRTY_BIT_TEXTURES,
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_TEXTURES); DIRTY_BIT_VERTEX_BUFFERS, DIRTY_BIT_INDEX_BUFFER, DIRTY_BIT_SHADER_RESOURCES,
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_VERTEX_BUFFERS); DIRTY_BIT_DESCRIPTOR_SETS, DIRTY_BIT_DRIVER_UNIFORMS_BINDING};
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_INDEX_BUFFER);
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_SHADER_RESOURCES);
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS);
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS_BINDING);
if (getFeatures().supportsTransformFeedbackExtension.enabled) if (getFeatures().supportsTransformFeedbackExtension.enabled)
{ {
mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_TRANSFORM_FEEDBACK_BUFFERS); mNewGraphicsCommandBufferDirtyBits.set(DIRTY_BIT_TRANSFORM_FEEDBACK_BUFFERS);
} }
mNewComputeCommandBufferDirtyBits.set(DIRTY_BIT_PIPELINE_BINDING); mNewComputeCommandBufferDirtyBits =
mNewComputeCommandBufferDirtyBits.set(DIRTY_BIT_TEXTURES); DirtyBits{DIRTY_BIT_PIPELINE_BINDING, DIRTY_BIT_TEXTURES, DIRTY_BIT_SHADER_RESOURCES,
mNewComputeCommandBufferDirtyBits.set(DIRTY_BIT_SHADER_RESOURCES); DIRTY_BIT_DESCRIPTOR_SETS, DIRTY_BIT_DRIVER_UNIFORMS_BINDING};
mNewComputeCommandBufferDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS);
mNewComputeCommandBufferDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS_BINDING);
mGraphicsDirtyBitHandlers[DIRTY_BIT_EVENT_LOG] = &ContextVk::handleDirtyGraphicsEventLog; mGraphicsDirtyBitHandlers[DIRTY_BIT_EVENT_LOG] = &ContextVk::handleDirtyGraphicsEventLog;
mGraphicsDirtyBitHandlers[DIRTY_BIT_DEFAULT_ATTRIBS] = mGraphicsDirtyBitHandlers[DIRTY_BIT_DEFAULT_ATTRIBS] =
...@@ -3483,10 +3485,8 @@ angle::Result ContextVk::invalidateCurrentTextures(const gl::Context *context) ...@@ -3483,10 +3485,8 @@ angle::Result ContextVk::invalidateCurrentTextures(const gl::Context *context)
if (executable->hasTextures()) if (executable->hasTextures())
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_TEXTURES); mGraphicsDirtyBits |= kTexturesAndDescSetDirtyBits;
mGraphicsDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS); mComputeDirtyBits |= kTexturesAndDescSetDirtyBits;
mComputeDirtyBits.set(DIRTY_BIT_TEXTURES);
mComputeDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS);
ANGLE_TRY(updateActiveTextures(context)); ANGLE_TRY(updateActiveTextures(context));
} }
...@@ -3502,25 +3502,20 @@ void ContextVk::invalidateCurrentShaderResources() ...@@ -3502,25 +3502,20 @@ void ContextVk::invalidateCurrentShaderResources()
if (executable->hasUniformBuffers() || executable->hasStorageBuffers() || if (executable->hasUniformBuffers() || executable->hasStorageBuffers() ||
executable->hasAtomicCounterBuffers() || executable->hasImages()) executable->hasAtomicCounterBuffers() || executable->hasImages())
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_SHADER_RESOURCES); mGraphicsDirtyBits |= kResourcesAndDescSetDirtyBits;
mGraphicsDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS); mComputeDirtyBits |= kResourcesAndDescSetDirtyBits;
mComputeDirtyBits.set(DIRTY_BIT_SHADER_RESOURCES);
mComputeDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS);
} }
} }
void ContextVk::invalidateGraphicsDriverUniforms() void ContextVk::invalidateGraphicsDriverUniforms()
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS); mGraphicsDirtyBits |= kDriverUniformsAndBindingDirtyBits;
mGraphicsDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS_BINDING);
} }
void ContextVk::invalidateDriverUniforms() void ContextVk::invalidateDriverUniforms()
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS); mGraphicsDirtyBits |= kDriverUniformsAndBindingDirtyBits;
mGraphicsDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS_BINDING); mComputeDirtyBits |= kDriverUniformsAndBindingDirtyBits;
mComputeDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS);
mComputeDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS_BINDING);
} }
void ContextVk::onFramebufferChange(FramebufferVk *framebufferVk) void ContextVk::onFramebufferChange(FramebufferVk *framebufferVk)
...@@ -3563,8 +3558,7 @@ void ContextVk::invalidateCurrentTransformFeedbackBuffers() ...@@ -3563,8 +3558,7 @@ void ContextVk::invalidateCurrentTransformFeedbackBuffers()
} }
else if (getFeatures().emulateTransformFeedback.enabled) else if (getFeatures().emulateTransformFeedback.enabled)
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_TRANSFORM_FEEDBACK_BUFFERS); mGraphicsDirtyBits |= kXfbBuffersAndDescSetDirtyBits;
mGraphicsDirtyBits.set(DIRTY_BIT_DESCRIPTOR_SETS);
} }
} }
...@@ -3572,8 +3566,8 @@ void ContextVk::onTransformFeedbackStateChanged() ...@@ -3572,8 +3566,8 @@ void ContextVk::onTransformFeedbackStateChanged()
{ {
if (getFeatures().supportsTransformFeedbackExtension.enabled) if (getFeatures().supportsTransformFeedbackExtension.enabled)
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_TRANSFORM_FEEDBACK_STATE); mGraphicsDirtyBits |=
mGraphicsDirtyBits.set(DIRTY_BIT_TRANSFORM_FEEDBACK_BUFFERS); DirtyBits{DIRTY_BIT_TRANSFORM_FEEDBACK_STATE, DIRTY_BIT_TRANSFORM_FEEDBACK_BUFFERS};
} }
else if (getFeatures().emulateTransformFeedback.enabled) else if (getFeatures().emulateTransformFeedback.enabled)
{ {
...@@ -3840,8 +3834,7 @@ void ContextVk::writeAtomicCounterBufferDriverUniformOffsets(uint32_t *offsetsOu ...@@ -3840,8 +3834,7 @@ void ContextVk::writeAtomicCounterBufferDriverUniformOffsets(uint32_t *offsetsOu
void ContextVk::pauseTransformFeedbackIfStartedAndRebindBuffersOnResume() void ContextVk::pauseTransformFeedbackIfStartedAndRebindBuffersOnResume()
{ {
DirtyBits rebindTransformFeedbackOnResume; DirtyBits rebindTransformFeedbackOnResume{DIRTY_BIT_TRANSFORM_FEEDBACK_STATE};
rebindTransformFeedbackOnResume.set(DIRTY_BIT_TRANSFORM_FEEDBACK_STATE);
pauseTransformFeedbackIfStarted(rebindTransformFeedbackOnResume); pauseTransformFeedbackIfStarted(rebindTransformFeedbackOnResume);
} }
......
src/libANGLE/renderer/vulkan/ContextVk.h
...@@ -301,8 +301,7 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText ...@@ -301,8 +301,7 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
ANGLE_INLINE void invalidateVertexAndIndexBuffers() ANGLE_INLINE void invalidateVertexAndIndexBuffers()
{ {
mGraphicsDirtyBits.set(DIRTY_BIT_VERTEX_BUFFERS); mGraphicsDirtyBits |= kIndexAndVertexDirtyBits;
mGraphicsDirtyBits.set(DIRTY_BIT_INDEX_BUFFER);
} }
angle::Result onVertexBufferChange(const vk::BufferHelper *vertexBuffer); angle::Result onVertexBufferChange(const vk::BufferHelper *vertexBuffer);
...@@ -760,14 +759,13 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText ...@@ -760,14 +759,13 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
ANGLE_INLINE void invalidateCurrentGraphicsPipeline() ANGLE_INLINE void invalidateCurrentGraphicsPipeline()
{ {
// Note: DIRTY_BIT_PIPELINE_BIND will be automatically set if pipeline bind is necessary. // Note: DIRTY_BIT_PIPELINE_BINDING will be automatically set if pipeline bind is necessary.
mGraphicsDirtyBits.set(DIRTY_BIT_PIPELINE_DESC); mGraphicsDirtyBits.set(DIRTY_BIT_PIPELINE_DESC);
} }
ANGLE_INLINE void invalidateCurrentComputePipeline() ANGLE_INLINE void invalidateCurrentComputePipeline()
{ {
mComputeDirtyBits.set(DIRTY_BIT_PIPELINE_DESC); mComputeDirtyBits |= kPipelineDescAndBindingDirtyBits;
mComputeDirtyBits.set(DIRTY_BIT_PIPELINE_BINDING);
mCurrentComputePipeline = nullptr; mCurrentComputePipeline = nullptr;
} }
...@@ -915,6 +913,18 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText ...@@ -915,6 +913,18 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
DirtyBits mIndexedDirtyBitsMask; DirtyBits mIndexedDirtyBitsMask;
DirtyBits mNewGraphicsCommandBufferDirtyBits; DirtyBits mNewGraphicsCommandBufferDirtyBits;
DirtyBits mNewComputeCommandBufferDirtyBits; DirtyBits mNewComputeCommandBufferDirtyBits;
static constexpr DirtyBits kIndexAndVertexDirtyBits{DIRTY_BIT_VERTEX_BUFFERS,
DIRTY_BIT_INDEX_BUFFER};
static constexpr DirtyBits kPipelineDescAndBindingDirtyBits{DIRTY_BIT_PIPELINE_DESC,
DIRTY_BIT_PIPELINE_BINDING};
static constexpr DirtyBits kTexturesAndDescSetDirtyBits{DIRTY_BIT_TEXTURES,
DIRTY_BIT_DESCRIPTOR_SETS};
static constexpr DirtyBits kResourcesAndDescSetDirtyBits{DIRTY_BIT_SHADER_RESOURCES,
DIRTY_BIT_DESCRIPTOR_SETS};
static constexpr DirtyBits kXfbBuffersAndDescSetDirtyBits{DIRTY_BIT_TRANSFORM_FEEDBACK_BUFFERS,
DIRTY_BIT_DESCRIPTOR_SETS};
static constexpr DirtyBits kDriverUniformsAndBindingDirtyBits{
DIRTY_BIT_DRIVER_UNIFORMS, DIRTY_BIT_DRIVER_UNIFORMS_BINDING};
// Cached back-end objects. // Cached back-end objects.
VertexArrayVk *mVertexArray; VertexArrayVk *mVertexArray;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment