File size: 2,818 Bytes
d1ceb73 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
#pragma once
#include <atomic>
#include <utility>
namespace c10 {
/**
* Thread-safe lazy value with opportunistic concurrency: on concurrent first
* access, the factory may be called by multiple threads, but only one result is
* stored and its reference returned to all the callers.
*
* Value is heap-allocated; this optimizes for the case in which the value is
* never actually computed.
*/
template <class T>
class OptimisticLazy {
public:
OptimisticLazy() = default;
OptimisticLazy(const OptimisticLazy& other) {
if (T* value = other.value_.load(std::memory_order_acquire)) {
value_ = new T(*value);
}
}
OptimisticLazy(OptimisticLazy&& other) noexcept
: value_(other.value_.exchange(nullptr, std::memory_order_acq_rel)) {}
~OptimisticLazy() {
reset();
}
template <class Factory>
T& ensure(Factory&& factory) {
if (T* value = value_.load(std::memory_order_acquire)) {
return *value;
}
T* value = new T(factory());
T* old = nullptr;
if (!value_.compare_exchange_strong(
old, value, std::memory_order_release, std::memory_order_acquire)) {
delete value;
value = old;
}
return *value;
}
// The following methods are not thread-safe: they should not be called
// concurrently with any other method.
OptimisticLazy& operator=(const OptimisticLazy& other) {
*this = OptimisticLazy{other};
return *this;
}
OptimisticLazy& operator=(OptimisticLazy&& other) noexcept {
if (this != &other) {
reset();
value_.store(
other.value_.exchange(nullptr, std::memory_order_acquire),
std::memory_order_release);
}
return *this;
}
void reset() {
if (T* old = value_.load(std::memory_order_relaxed)) {
value_.store(nullptr, std::memory_order_relaxed);
delete old;
}
}
private:
std::atomic<T*> value_{nullptr};
};
/**
* Interface for a value that is computed on first access.
*/
template <class T>
class LazyValue {
public:
virtual ~LazyValue() = default;
virtual const T& get() const = 0;
};
/**
* Convenience thread-safe LazyValue implementation with opportunistic
* concurrency.
*/
template <class T>
class OptimisticLazyValue : public LazyValue<T> {
public:
const T& get() const override {
return value_.ensure([this] { return compute(); });
}
private:
virtual T compute() const = 0;
mutable OptimisticLazy<T> value_;
};
/**
* Convenience immutable (thus thread-safe) LazyValue implementation for cases
* in which the value is not actually lazy.
*/
template <class T>
class PrecomputedLazyValue : public LazyValue<T> {
public:
PrecomputedLazyValue(T value) : value_(std::move(value)) {}
const T& get() const override {
return value_;
}
private:
T value_;
};
} // namespace c10
|