Port SkRefCnt.h to new SkAtomics.h

include/core/SkRefCnt.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 SkRefCnt_DEFINED
 #define SkRefCnt_DEFINED
 
-#include "SkDynamicAnnotations.h"
-#include "SkThread.h"
+#include "SkAtomics.h"
 #include "SkInstCnt.h"
 #include "SkTemplates.h"
 
 /** \class SkRefCntBase
 
     SkRefCntBase is the base class for objects that may be shared by multiple
     objects. When an existing owner wants to share a reference, it calls ref().
     When an owner wants to release its reference, it calls unref(). When the
     shared object's reference count goes to zero as the result of an unref()
     call, its (virtual) destructor is called. It is an error for the
@@ skipping 19 matching lines @@
 
 #ifdef SK_DEBUG
     /** Return the reference count. Use only for debugging. */
     int32_t getRefCnt() const { return fRefCnt; }
 #endif
 
     /** May return true if the caller is the only owner.
      *  Ensures that all previous owner's actions are complete.
      */
     bool unique() const {
-        // We believe we're reading fRefCnt in a safe way here, so we stifle the TSAN warning about
-        // an unproctected read.  Generally, don't read fRefCnt, and don't stifle this warning.
-        bool const unique = (1 == sk_acquire_load(&fRefCnt));
-        if (unique) {
-            // Acquire barrier (L/SL), if not provided by load of fRefCnt.
-            // Prevents user's 'unique' code from happening before decrements.
-            //TODO: issue the barrier only when unique is true
+        if (1 == sk_atomic_load(&fRefCnt, sk_memory_order_relaxed)) {
+            // Prevents code conditioned on the result of unique() from running
+            // until previous owners are all totally done calling unref().
+            sk_memory_barrier(sk_memory_order_acquire);
+            return true;
         }
-        return unique;
+        return false;
     }
 
     /** Increment the reference count. Must be balanced by a call to unref().
     */
     void ref() const {
         SkASSERT(fRefCnt > 0);
-        sk_atomic_inc(&fRefCnt);  // No barrier required.
+        (void)sk_atomic_fetch_add(&fRefCnt, +1, sk_memory_order_relaxed);  // No barrier required.
     }
 
     /** Decrement the reference count. If the reference count is 1 before the
         decrement, then delete the object. Note that if this is the case, then
         the object needs to have been allocated via new, and not on the stack.
     */
     void unref() const {
         SkASSERT(fRefCnt > 0);
-        // Release barrier (SL/S), if not provided below.
-        if (sk_atomic_dec(&fRefCnt) == 1) {
-            // Acquire barrier (L/SL), if not provided above.
-            // Prevents code in dispose from happening before the decrement.
-            sk_membar_acquire__after_atomic_dec();
-            internal_dispose();
+        // A release here acts in place of all releases we "should" have been doing in ref().
+        // An acquire makes sure code in internal_dispose() doen't happen before the decrement.

[bungeman-skia, 2015/02/03 17:14:47]

nit: doen't?

I liked the way it was clear before that the algorithm itself only needs the
acquire inside this block, mostly because it's needed for exactly the same
reasons the acquire in "unique" is needed. I know it doesn't make any practical
difference, but I'd like this comment to somehow point out more explicitly
somehow that the acquire logically is only needed inside the block, and that
this is the same situation as "unique".

[mtklein, 2015/02/03 17:27:57]

Done.

+        if (1 == sk_atomic_fetch_add(&fRefCnt, -1, sk_memory_order_acq_rel)) {
+            this->internal_dispose();
         }
     }
 
 #ifdef SK_DEBUG
     void validate() const {
         SkASSERT(fRefCnt > 0);
     }
 #endif
 
 protected:
@@ skipping 161 matching lines @@
 class SkNVRefCnt : SkNoncopyable {
 public:
     SkNVRefCnt() : fRefCnt(1) {}
     ~SkNVRefCnt() { SkASSERTF(1 == fRefCnt, "NVRefCnt was %d", fRefCnt); }
 
     // Implementation is pretty much the same as SkRefCntBase. All required barriers are the same:
     //   - unique() needs acquire when it returns true, and no barrier if it returns false;
     //   - ref() doesn't need any barrier;
     //   - unref() needs a release barrier, and an acquire if it's going to call delete.
 
-    bool unique() const { return 1 == sk_acquire_load(&fRefCnt); }
-    void    ref() const { sk_atomic_inc(&fRefCnt); }
-    void  unref() const {
-        int32_t prevValue = sk_atomic_dec(&fRefCnt);
-        SkASSERT(prevValue >= 1);
-        if (1 == prevValue) {
+    bool unique() const {
+        if (1 == sk_atomic_load(&fRefCnt, sk_memory_order_relaxed)) {
+            sk_memory_barrier(sk_memory_order_acquire);
+            return true;
+        }
+        return false;
+    }
+    void   ref() const { (void)sk_atomic_fetch_add(&fRefCnt, +1, sk_memory_order_relaxed); }
+    void unref() const {
+        if (1 == sk_atomic_fetch_add(&fRefCnt, -1, sk_memory_order_acq_rel)) {
             SkDEBUGCODE(fRefCnt = 1;)   // restore the 1 for our destructor's assert
             SkDELETE((const Derived*)this);
         }
     }
-    void  deref() const { this->unref(); }  // Chrome prefers to call deref().
+    void deref() const { this->unref(); }  // Chrome prefers to call deref().

[bungeman-skia, 2015/02/03 17:14:47]

I know it has nothing to do with this CL, but I still cringe every time I see
this line. Yes, it's the minimum to magically make this work with Blink, but
Chromium actually wants AddRef/Release (so the comment is wrong, it's Blink that
want's deref). Also, while this is the minimal amount to make things work, Blink
also wants adopted and requireAdoption (see
https://code.google.com/p/chromium/codesearch#chromium/src/skia/config/sk_ref...
).

[mtklein, 2015/02/03 17:27:57]

Done.

 
 private:
     mutable int32_t fRefCnt;
 };
 
 #endif