Remove 64-bit android_atomic uses from StateQueue.

Use stdatomic.h instead.  We're trying to remove android_atomic use
wherever possible.  The 64-bit uses seem easiest to remove first.
This cleans up the code, though not as much as C++ <atomic> would,
if it worked everywhere.

Change-Id: I3c29bdbd5915cb9d47118834a3a742fe296cf87f

2 files changed, 8 insertions, 12 deletions

diff --git a/services/audioflinger/StateQueue.cpp b/services/audioflinger/StateQueue.cpp
index 7e01c9f..40d7bcd 100644
--- a/services/audioflinger/StateQueue.cpp
+++ b/services/audioflinger/StateQueue.cpp
@@ -41,13 +41,14 @@ void StateQueueMutatorDump::dump(int fd)
 // Constructor and destructor
 
 template<typename T> StateQueue<T>::StateQueue() :
-    mNext(NULL), mAck(NULL), mCurrent(NULL),
+    mAck(NULL), mCurrent(NULL),
     mMutating(&mStates[0]), mExpecting(NULL),
     mInMutation(false), mIsDirty(false), mIsInitialized(false)
 #ifdef STATE_QUEUE_DUMP
     , mObserverDump(&mObserverDummyDump), mMutatorDump(&mMutatorDummyDump)
 #endif
 {
+    atomic_init(&mNext, 0);
 }
 
 template<typename T> StateQueue<T>::~StateQueue()
@@ -58,11 +59,8 @@ template<typename T> StateQueue<T>::~StateQueue()
 
 template<typename T> const T* StateQueue<T>::poll()
 {
-#ifdef __LP64__
-    const T *next = (const T *) android_atomic_acquire_load64((volatile int64_t *) &mNext);
-#else
-    const T *next = (const T *) android_atomic_acquire_load((volatile int32_t *) &mNext);
-#endif
+    const T *next = (const T *) atomic_load_explicit(&mNext, memory_order_acquire);
+
     if (next != mCurrent) {
         mAck = next;    // no additional barrier needed
         mCurrent = next;
@@ -144,11 +142,7 @@ template<typename T> bool StateQueue<T>::push(StateQueue<T>::block_t block)
         }
 
         // publish
-#ifdef __LP64__
-        android_atomic_release_store64((int64_t) mMutating, (volatile int64_t *) &mNext);
-#else
-        android_atomic_release_store((int32_t) mMutating, (volatile int32_t *) &mNext);
-#endif
+        atomic_store_explicit(&mNext, (uintptr_t)mMutating, memory_order_release);
         mExpecting = mMutating;
 
         // copy with circular wraparound
diff --git a/services/audioflinger/StateQueue.h b/services/audioflinger/StateQueue.h
index 9cde642..ef01df7 100644
--- a/services/audioflinger/StateQueue.h
+++ b/services/audioflinger/StateQueue.h
@@ -17,6 +17,8 @@
 #ifndef ANDROID_AUDIO_STATE_QUEUE_H
 #define ANDROID_AUDIO_STATE_QUEUE_H
 
+#include <stdatomic.h>
+
 // The state queue template class was originally driven by this use case / requirements:
 //  There are two threads: a fast mixer, and a normal mixer, and they share state.
 //  The interesting part of the shared state is a set of active fast tracks,
@@ -184,7 +186,7 @@ private:
     T                 mStates[kN];      // written by mutator, read by observer
 
     // "volatile" is meaningless with SMP, but here it indicates that we're using atomic ops
-    volatile const T* mNext; // written by mutator to advance next, read by observer
+    atomic_uintptr_t  mNext; // written by mutator to advance next, read by observer
     volatile const T* mAck;  // written by observer to acknowledge advance of next, read by mutator
 
     // only used by observer