Use a spinlock in SkOnce.

include/core/SkThread.h

Index: include/core/SkThread.h
diff --git a/include/core/SkThread.h b/include/core/SkThread.h
index 412ace31eb24f64e31c1d2e9529d24a3c004e95a..fbd7fe2ec740df5729156b3d86e57a46f3ff76c6 100644
--- a/include/core/SkThread.h
+++ b/include/core/SkThread.h
@@ -33,6 +33,11 @@ static int32_t sk_atomic_dec(int32_t* addr);
  */
 static int32_t sk_atomic_conditional_inc(int32_t* addr);
 
+/** Atomic compare and set.
+ *  If *addr == before, set *addr to after and return true, otherwise return false.

[bungeman-skia, 2014/01/07 22:05:41]

This needs to state the memory barriers provided. Note that this often comes in
_acquire, _release, and _none versions.

[mtklein, 2014/01/08 17:02:18]

Thanks for reminding me.  Now done.

I updated _android to use android_atomic_release_cas.  android_atomic_cas wasn't
actually part of the public API, but because it's all header it got sucked in. 
Turns they also have a bizarre return type, returning int 0 on success and
something else otherwise, so I fixed my inverted logic.

_sync and _win already provide a full memory barrier, so no changes needed
there.  _none of course needed no changes.

+ */
+static bool sk_atomic_cas(int32_t* addr, int32_t before, int32_t after);
+
 /** If sk_atomic_dec does not act as an acquire (L/SL) barrier,
  *  this must act as an acquire (L/SL) memory barrier and as a compiler barrier.
  */
@@ -45,6 +50,32 @@ static void sk_membar_acquire__after_atomic_conditional_inc();
 
 #include SK_ATOMICS_PLATFORM_H
 
+// This is POD and must be zero-initialized.
+struct SkSpinlock {
+    void acquire() {
+        SkASSERT(shouldBeZero == 0);
+        while (!sk_atomic_cas(&thisIsPrivate, 0, 1)) {

[bungeman-skia, 2014/01/07 22:05:41]

This doesn't need a barrier.

(It doesn't look like you've annotated the barriers provided by sk_atomic_cas,
and there should be comments here about what barriers are required for the
algorithm to work.)

[mtklein, 2014/01/08 17:02:18]

Done.  Conceivably this might need a store barrier, right?  Otherwise if it
happened to be the only process running on some CPU, it might never actually see
some other thread on another CPU drop the lock.

sk_atomic_cas actually performs a full barrier in all implementations now, so in
practice it's moot.

+            // spin
+        }
+    }
+
+    void release() {
+        SkASSERT(shouldBeZero == 0);
+        SkAssertResult(sk_atomic_cas(&thisIsPrivate, 1, 0));

[bungeman-skia, 2014/01/07 22:05:41]

This needs a store:store/load:store (release) barrier before the store.

[mtklein, 2014/01/08 17:02:18]

Done.

[mtklein, 2014/01/08 17:02:18]

Done.  Now guaranteed by sk_atomic_cas.

+    }
+
+    int32_t thisIsPrivate;
+    SkDEBUGCODE(int32_t shouldBeZero;)
+};
+
+class SkAutoSpinlock : SkNoncopyable {
+public:
+    explicit SkAutoSpinlock(SkSpinlock* lock) : fLock(lock) { fLock->acquire(); }
+    ~SkAutoSpinlock() { fLock->release(); }
+private:
+    SkSpinlock* fLock;
+};
+#define SkAutoSpinlock(...) SK_REQUIRE_LOCAL_VAR(SkAutoSpinlock)
 
 /** SK_MUTEX_PLATFORM_H must provide the following (or equivalent) declarations.