Use a spinlock in SkOnce.

include/core/SkThread.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkThread_DEFINED
 #define SkThread_DEFINED
 
@@ skipping 15 matching lines @@
  *  This must act as a release (SL/S) memory barrier and as a compiler barrier.
  */
 static int32_t sk_atomic_dec(int32_t* addr);
 
 /** Atomically adds one to the int referenced by addr iff the referenced int was not 0
  *  and returns the previous value.
  *  No additional memory barrier is required; this must act as a compiler barrier.
  */
 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.
  */
 static void sk_membar_acquire__after_atomic_dec();
 
 /** If sk_atomic_conditional_inc does not act as an acquire (L/SL) barrier,
  *  this must act as an acquire (L/SL) memory barrier and as a compiler barrier.
  */
 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.
 
 class SkBaseMutex {
 public:
     void acquire();
     void release();
 };
 
 class SkMutex : SkBaseMutex {
@@ skipping 36 matching lines @@
             fMutex = NULL;
         }
     }
 
 private:
     SkBaseMutex* fMutex;
 };
 #define SkAutoMutexAcquire(...) SK_REQUIRE_LOCAL_VAR(SkAutoMutexAcquire)
 
 #endif