Index: include/private/SkOnce.h |
diff --git a/include/private/SkOnce.h b/include/private/SkOnce.h |
index 20bf427678e49c56e7a60a82ffa1c468f042a422..d83b63f2837382f0179a0c987a67b8a2f979f3b7 100644 |
--- a/include/private/SkOnce.h |
+++ b/include/private/SkOnce.h |
@@ -8,9 +8,9 @@ |
#ifndef SkOnce_DEFINED |
#define SkOnce_DEFINED |
+#include "../private/SkSpinlock.h" |
#include <atomic> |
#include <utility> |
-#include "SkTypes.h" |
// SkOnce provides call-once guarantees for Skia, much like std::once_flag/std::call_once(). |
// |
@@ -21,50 +21,20 @@ |
public: |
template <typename Fn, typename... Args> |
void operator()(Fn&& fn, Args&&... args) { |
- auto state = fState.load(std::memory_order_acquire); |
- |
- if (state == Done) { |
- return; |
+ // Vanilla double-checked locking. |
+ if (!fDone.load(std::memory_order_acquire)) { |
+ fLock.acquire(); |
+ if (!fDone.load(std::memory_order_relaxed)) { |
+ fn(std::forward<Args>(args)...); |
+ fDone.store(true, std::memory_order_release); |
+ } |
+ fLock.release(); |
} |
- |
- if (state == NotStarted) { |
- // Try to claim the job of calling fn() by swapping from NotStarted to Calling. |
- // See [1] below for why we use std::memory_order_acquire instead of relaxed. |
- if (fState.compare_exchange_strong(state, Calling, std::memory_order_acquire)) { |
- // Claimed! Call fn(), then mark this SkOnce as Done. |
- fn(std::forward<Args>(args)...); |
- return fState.store(Done, std::memory_order_release); |
- } |
- } |
- |
- while (state == Calling) { |
- // Some other thread is calling fn(). Wait for them to finish. |
- state = fState.load(std::memory_order_acquire); |
- } |
- SkASSERT(state == Done); |
} |
private: |
- enum State : uint8_t { NotStarted, Calling, Done}; |
- std::atomic<State> fState{NotStarted}; |
+ std::atomic<bool> fDone{false}; |
+ SkSpinlock fLock; |
}; |
-/* [1] Why do we compare_exchange_strong() with std::memory_order_acquire instead of relaxed? |
- * |
- * If we succeed, we really only need a relaxed compare_exchange_strong()... we're the ones |
- * who are about to do a release store, so there's certainly nothing yet for an acquire to |
- * synchronize with. |
- * |
- * If that compare_exchange_strong() fails, we're either in Calling or Done state. |
- * Again, if we're in Calling state, relaxed would have been fine: the spin loop will |
- * acquire up to the Calling thread's release store. |
- * |
- * But if that compare_exchange_strong() fails and we find ourselves in the Done state, |
- * we've never done an acquire load to sync up to the store of that Done state. |
- * |
- * So on failure we need an acquire load. Generally the failure memory order cannot be |
- * stronger than the success memory order, so we need acquire on success too. The single |
- * memory order version of compare_exchange_strong() uses the same acquire order for both. |
- */ |
- |
#endif // SkOnce_DEFINED |