Source code
Revision control
Copy as Markdown
Other Tools
//
// Copyright 2021 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// SynchronizedValue.h:
// A class that ensures that the correct mutex is locked when the encapsulated data is accessed.
// Based on boost::synchronized_value, which probably becomes part of the next C++ standard.
#ifndef COMMON_SYNCHRONIZEDVALUE_H_
#define COMMON_SYNCHRONIZEDVALUE_H_
#include "common/debug.h"
#include <mutex>
#include <type_traits>
namespace angle
{
template <typename T, typename Lockable = std::mutex>
class ConstStrictLockPtr
{
public:
using value_type = T;
using mutex_type = Lockable;
ConstStrictLockPtr(const T &value, Lockable &mutex) : mLock(mutex), mValue(value) {}
ConstStrictLockPtr(const T &value, Lockable &mutex, std::adopt_lock_t) noexcept
: mLock(mutex, std::adopt_lock), mValue(value)
{}
ConstStrictLockPtr(ConstStrictLockPtr &&other) noexcept
: mLock(std::move(other.mLock)), mValue(other.mValue)
{}
ConstStrictLockPtr(const ConstStrictLockPtr &) = delete;
ConstStrictLockPtr &operator=(const ConstStrictLockPtr &) = delete;
~ConstStrictLockPtr() = default;
const T *operator->() const { return &mValue; }
const T &operator*() const { return mValue; }
protected:
std::unique_lock<Lockable> mLock;
T const &mValue;
};
template <typename T, typename Lockable = std::mutex>
class StrictLockPtr : public ConstStrictLockPtr<T, Lockable>
{
private:
using BaseType = ConstStrictLockPtr<T, Lockable>;
public:
StrictLockPtr(T &value, Lockable &mutex) : BaseType(value, mutex) {}
StrictLockPtr(T &value, Lockable &mutex, std::adopt_lock_t) noexcept
: BaseType(value, mutex, std::adopt_lock)
{}
StrictLockPtr(StrictLockPtr &&other) noexcept
: BaseType(std::move(static_cast<BaseType &&>(other)))
{}
StrictLockPtr(const StrictLockPtr &) = delete;
StrictLockPtr &operator=(const StrictLockPtr &) = delete;
~StrictLockPtr() = default;
T *operator->() { return const_cast<T *>(&this->mValue); }
T &operator*() { return const_cast<T &>(this->mValue); }
};
template <typename SV>
struct SynchronizedValueStrictLockPtr
{
using type = StrictLockPtr<typename SV::value_type, typename SV::mutex_type>;
};
template <typename SV>
struct SynchronizedValueStrictLockPtr<const SV>
{
using type = ConstStrictLockPtr<typename SV::value_type, typename SV::mutex_type>;
};
template <typename T, typename Lockable = std::mutex>
class ConstUniqueLockPtr : public std::unique_lock<Lockable>
{
private:
using BaseType = std::unique_lock<Lockable>;
public:
using value_type = T;
using mutex_type = Lockable;
ConstUniqueLockPtr(const T &value, Lockable &mutex) : BaseType(mutex), mValue(value) {}
ConstUniqueLockPtr(const T &value, Lockable &mutex, std::adopt_lock_t) noexcept
: BaseType(mutex, std::adopt_lock), mValue(value)
{}
ConstUniqueLockPtr(const T &value, Lockable &mutex, std::defer_lock_t) noexcept
: BaseType(mutex, std::defer_lock), mValue(value)
{}
ConstUniqueLockPtr(const T &value, Lockable &mutex, std::try_to_lock_t) noexcept
: BaseType(mutex, std::try_to_lock), mValue(value)
{}
ConstUniqueLockPtr(ConstUniqueLockPtr &&other) noexcept
: BaseType(std::move(static_cast<BaseType &&>(other))), mValue(other.mValue)
{}
ConstUniqueLockPtr(const ConstUniqueLockPtr &) = delete;
ConstUniqueLockPtr &operator=(const ConstUniqueLockPtr &) = delete;
~ConstUniqueLockPtr() = default;
const T *operator->() const
{
ASSERT(this->owns_lock());
return &mValue;
}
const T &operator*() const
{
ASSERT(this->owns_lock());
return mValue;
}
protected:
T const &mValue;
};
template <typename T, typename Lockable = std::mutex>
class UniqueLockPtr : public ConstUniqueLockPtr<T, Lockable>
{
private:
using BaseType = ConstUniqueLockPtr<T, Lockable>;
public:
UniqueLockPtr(T &value, Lockable &mutex) : BaseType(value, mutex) {}
UniqueLockPtr(T &value, Lockable &mutex, std::adopt_lock_t) noexcept
: BaseType(value, mutex, std::adopt_lock)
{}
UniqueLockPtr(T &value, Lockable &mutex, std::defer_lock_t) noexcept
: BaseType(value, mutex, std::defer_lock)
{}
UniqueLockPtr(T &value, Lockable &mutex, std::try_to_lock_t) noexcept
: BaseType(value, mutex, std::try_to_lock)
{}
UniqueLockPtr(UniqueLockPtr &&other) noexcept
: BaseType(std::move(static_cast<BaseType &&>(other)))
{}
UniqueLockPtr(const UniqueLockPtr &) = delete;
UniqueLockPtr &operator=(const UniqueLockPtr &) = delete;
~UniqueLockPtr() = default;
T *operator->()
{
ASSERT(this->owns_lock());
return const_cast<T *>(&this->mValue);
}
T &operator*()
{
ASSERT(this->owns_lock());
return const_cast<T &>(this->mValue);
}
};
template <typename SV>
struct SynchronizedValueUniqueLockPtr
{
using type = UniqueLockPtr<typename SV::value_type, typename SV::mutex_type>;
};
template <typename SV>
struct SynchronizedValueUniqueLockPtr<const SV>
{
using type = ConstUniqueLockPtr<typename SV::value_type, typename SV::mutex_type>;
};
template <typename T, typename Lockable = std::mutex>
class SynchronizedValue
{
public:
using value_type = T;
using mutex_type = Lockable;
SynchronizedValue() noexcept(std::is_nothrow_default_constructible<T>::value) : mValue() {}
SynchronizedValue(const T &other) noexcept(std::is_nothrow_copy_constructible<T>::value)
: mValue(other)
{}
SynchronizedValue(T &&other) noexcept(std::is_nothrow_move_constructible<T>::value)
: mValue(std::move(other))
{}
template <typename... Args>
SynchronizedValue(Args &&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
: mValue(std::forward<Args>(args)...)
{}
SynchronizedValue(const SynchronizedValue &other)
{
std::lock_guard<Lockable> lock(other.mMutex);
mValue = other.mValue;
}
SynchronizedValue(SynchronizedValue &&other)
{
std::lock_guard<Lockable> lock(other.mMutex);
mValue = std::move(other.mValue);
}
SynchronizedValue &operator=(const SynchronizedValue &other)
{
if (&other != this)
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
mValue = other.mValue;
}
return *this;
}
SynchronizedValue &operator=(SynchronizedValue &&other)
{
if (&other != this)
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
mValue = std::move(other.mValue);
}
return *this;
}
SynchronizedValue &operator=(const T &value)
{
{
std::lock_guard<Lockable> lock(mMutex);
mValue = value;
}
return *this;
}
SynchronizedValue &operator=(T &&value)
{
{
std::lock_guard<Lockable> lock(mMutex);
mValue = std::move(value);
}
return *this;
}
T get() const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue;
}
explicit operator T() const { return get(); }
void swap(SynchronizedValue &other)
{
if (this == &other)
{
return;
}
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
std::swap(mValue, other.mValue);
}
void swap(T &other)
{
std::lock_guard<Lockable> lock(mMutex);
std::swap(mValue, other);
}
StrictLockPtr<T, Lockable> operator->() { return StrictLockPtr<T, Lockable>(mValue, mMutex); }
ConstStrictLockPtr<T, Lockable> operator->() const
{
return ConstStrictLockPtr<T, Lockable>(mValue, mMutex);
}
StrictLockPtr<T, Lockable> synchronize() { return StrictLockPtr<T, Lockable>(mValue, mMutex); }
ConstStrictLockPtr<T, Lockable> synchronize() const
{
return ConstStrictLockPtr<T, Lockable>(mValue, mMutex);
}
UniqueLockPtr<T, Lockable> unique_synchronize()
{
return UniqueLockPtr<T, Lockable>(mValue, mMutex);
}
ConstUniqueLockPtr<T, Lockable> unique_synchronize() const
{
return ConstUniqueLockPtr<T, Lockable>(mValue, mMutex);
}
UniqueLockPtr<T, Lockable> defer_synchronize() noexcept
{
return UniqueLockPtr<T, Lockable>(mValue, mMutex, std::defer_lock);
}
ConstUniqueLockPtr<T, Lockable> defer_synchronize() const noexcept
{
return ConstUniqueLockPtr<T, Lockable>(mValue, mMutex, std::defer_lock);
}
UniqueLockPtr<T, Lockable> try_to_synchronize() noexcept
{
return UniqueLockPtr<T, Lockable>(mValue, mMutex, std::try_to_lock);
}
ConstUniqueLockPtr<T, Lockable> try_to_synchronize() const noexcept
{
return ConstUniqueLockPtr<T, Lockable>(mValue, mMutex, std::try_to_lock);
}
UniqueLockPtr<T, Lockable> adopt_synchronize() noexcept
{
return UniqueLockPtr<T, Lockable>(mValue, mMutex, std::adopt_lock);
}
ConstUniqueLockPtr<T, Lockable> adopt_synchronize() const noexcept
{
return ConstUniqueLockPtr<T, Lockable>(mValue, mMutex, std::adopt_lock);
}
class DerefValue
{
public:
DerefValue(DerefValue &&other) : mLock(std::move(other.mLock)), mValue(other.mValue) {}
DerefValue(const DerefValue &) = delete;
DerefValue &operator=(const DerefValue &) = delete;
operator T &() { return mValue; }
DerefValue &operator=(const T &other)
{
mValue = other;
return *this;
}
private:
explicit DerefValue(SynchronizedValue &outer) : mLock(outer.mMutex), mValue(outer.mValue) {}
std::unique_lock<Lockable> mLock;
T &mValue;
friend class SynchronizedValue;
};
class ConstDerefValue
{
public:
ConstDerefValue(ConstDerefValue &&other)
: mLock(std::move(other.mLock)), mValue(other.mValue)
{}
ConstDerefValue(const ConstDerefValue &) = delete;
ConstDerefValue &operator=(const ConstDerefValue &) = delete;
operator const T &() { return mValue; }
private:
explicit ConstDerefValue(const SynchronizedValue &outer)
: mLock(outer.mMutex), mValue(outer.mValue)
{}
std::unique_lock<Lockable> mLock;
const T &mValue;
friend class SynchronizedValue;
};
DerefValue operator*() { return DerefValue(*this); }
ConstDerefValue operator*() const { return ConstDerefValue(*this); }
template <typename OStream>
void save(OStream &os) const
{
std::lock_guard<Lockable> lock(mMutex);
os << mValue;
}
template <typename IStream>
void load(IStream &is)
{
std::lock_guard<Lockable> lock(mMutex);
is >> mValue;
}
bool operator==(const SynchronizedValue &other) const
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
return mValue == other.mValue;
}
bool operator!=(const SynchronizedValue &other) const
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
return mValue != other.mValue;
}
bool operator<(const SynchronizedValue &other) const
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
return mValue < other.mValue;
}
bool operator>(const SynchronizedValue &other) const
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
return mValue > other.mValue;
}
bool operator<=(const SynchronizedValue &other) const
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
return mValue <= other.mValue;
}
bool operator>=(const SynchronizedValue &other) const
{
std::unique_lock<Lockable> lock1(mMutex, std::defer_lock);
std::unique_lock<Lockable> lock2(other.mMutex, std::defer_lock);
std::lock(lock1, lock2);
return mValue >= other.mValue;
}
bool operator==(const T &other) const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue == other;
}
bool operator!=(const T &other) const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue != other;
}
bool operator<(const T &other) const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue < other;
}
bool operator>(const T &other) const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue > other;
}
bool operator<=(const T &other) const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue <= other;
}
bool operator>=(const T &other) const
{
std::lock_guard<Lockable> lock(mMutex);
return mValue >= other;
}
private:
T mValue;
mutable Lockable mMutex;
};
template <typename OStream, typename T, typename L>
inline OStream &operator<<(OStream &os, SynchronizedValue<T, L> const &sv)
{
sv.save(os);
return os;
}
template <typename IStream, typename T, typename L>
inline IStream &operator>>(IStream &is, SynchronizedValue<T, L> &sv)
{
sv.load(is);
return is;
}
template <typename T, typename L>
bool operator==(const T &lhs, const SynchronizedValue<T, L> &rhs)
{
return rhs == lhs;
}
template <typename T, typename L>
bool operator!=(const T &lhs, const SynchronizedValue<T, L> &rhs)
{
return rhs != lhs;
}
template <typename T, typename L>
bool operator<(const T &lhs, const SynchronizedValue<T, L> &rhs)
{
return rhs < lhs;
}
template <typename T, typename L>
bool operator>(const T &lhs, const SynchronizedValue<T, L> &rhs)
{
return rhs > lhs;
}
template <typename T, typename L>
bool operator<=(const T &lhs, const SynchronizedValue<T, L> &rhs)
{
return rhs <= lhs;
}
template <typename T, typename L>
bool operator>=(const T &lhs, const SynchronizedValue<T, L> &rhs)
{
return rhs >= lhs;
}
} // namespace angle
#endif // COMMON_SYNCHRONIZEDVALUE_H_