Make the device clock members atomic

Even though they're protected by a SeqLock of sorts, it's still UB to read and
write non-atomic vars from different threads. It's fine to do relaxed reads and
writes given the lock though, to help alleviate the cost.

alc/alc.cpp

@@ -976,10 +976,18 @@ std::unique_ptr<Compressor> CreateDeviceLimiter(const ALCdevice *device, const f
  */
 inline void UpdateClockBase(ALCdevice *device)
 {
-    IncrementRef(device->MixCount);
-    device->ClockBase += nanoseconds{seconds{device->SamplesDone}} / device->Frequency;
-    device->SamplesDone = 0;
-    IncrementRef(device->MixCount);
+    const auto mixCount = device->MixCount.load(std::memory_order_relaxed);
+    device->MixCount.store(mixCount+1, std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_release);
+
+    auto samplesDone = device->mSamplesDone.load(std::memory_order_relaxed);
+    auto clockBase = device->mClockBase.load(std::memory_order_relaxed);
+
+    clockBase += nanoseconds{seconds{samplesDone}} / device->Frequency;
+    device->mClockBase.store(clockBase, std::memory_order_relaxed);
+    device->mSamplesDone.store(0, std::memory_order_relaxed);
+
+    device->MixCount.store(mixCount+2, std::memory_order_release);
 }
 
 /**
@@ -2504,8 +2512,8 @@ ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname,
             nanoseconds basecount;
             do {
                 refcount = dev->waitForMix();
-                basecount = dev->ClockBase;
-                samplecount = dev->SamplesDone;
+                basecount = dev->mClockBase.load(std::memory_order_relaxed);
+                samplecount = dev->mSamplesDone.load(std::memory_order_relaxed);
             } while(refcount != ReadRef(dev->MixCount));
             basecount += nanoseconds{seconds{samplecount}} / dev->Frequency;
             *values = basecount.count();

alc/alu.cpp

@@ -1910,8 +1910,9 @@ void ProcessContexts(DeviceBase *device, const uint SamplesToDo)
 {
     ASSUME(SamplesToDo > 0);
 
-    const nanoseconds curtime{device->ClockBase +
-        nanoseconds{seconds{device->SamplesDone}}/device->Frequency};
+    const nanoseconds curtime{device->mClockBase.load(std::memory_order_relaxed) +
+        nanoseconds{seconds{device->mSamplesDone.load(std::memory_order_relaxed)}}/
+        device->Frequency};
 
     for(ContextBase *ctx : *device->mContexts.load(std::memory_order_acquire))
     {
@@ -2135,7 +2136,9 @@ uint DeviceBase::renderSamples(const uint numSamples)
         buffer.fill(0.0f);
 
     /* Increment the mix count at the start (lsb should now be 1). */
-    IncrementRef(MixCount);
+    const auto mixCount = MixCount.load(std::memory_order_relaxed);
+    MixCount.store(mixCount+1, std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_release);
 
     /* Process and mix each context's sources and effects. */
     ProcessContexts(this, samplesToDo);
@@ -2144,12 +2147,16 @@ uint DeviceBase::renderSamples(const uint numSamples)
      * and added to clock base so that large sample counts don't overflow
      * during conversion. This also guarantees a stable conversion.
      */
-    SamplesDone += samplesToDo;
-    ClockBase += std::chrono::seconds{SamplesDone / Frequency};
-    SamplesDone %= Frequency;
+    {
+        auto samplesDone = mSamplesDone.load(std::memory_order_relaxed) + samplesToDo;
+        auto clockBase = mClockBase.load(std::memory_order_relaxed) +
+            std::chrono::seconds{samplesDone/Frequency};
+        mSamplesDone.store(samplesDone%Frequency, std::memory_order_relaxed);
+        mClockBase.store(clockBase, std::memory_order_relaxed);
+    }
 
     /* Increment the mix count at the end (lsb should now be 0). */
-    IncrementRef(MixCount);
+    MixCount.store(mixCount+2, std::memory_order_release);
 
     /* Apply any needed post-process for finalizing the Dry mix to the RealOut
      * (Ambisonic decode, UHJ encode, etc).
@@ -2225,7 +2232,10 @@ void DeviceBase::renderSamples(void *outBuffer, const uint numSamples, const siz
 
 void DeviceBase::handleDisconnect(const char *msg, ...)
 {
-    IncrementRef(MixCount);
+    const auto mixCount = MixCount.load(std::memory_order_relaxed);
+    MixCount.store(mixCount+1, std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_release);
+
     if(Connected.exchange(false, std::memory_order_acq_rel))
     {
         AsyncEvent evt{std::in_place_type<AsyncDisconnectEvent>};
@@ -2267,5 +2277,6 @@ void DeviceBase::handleDisconnect(const char *msg, ...)
             std::for_each(voicelist.begin(), voicelist.end(), stop_voice);
         }
     }
-    IncrementRef(MixCount);
+
+    MixCount.store(mixCount+2, std::memory_order_release);
 }

alc/backends/base.h

@@ -55,14 +55,8 @@ enum class BackendType {
 /* Helper to get the current clock time from the device's ClockBase, and
  * SamplesDone converted from the sample rate.
  */
-inline std::chrono::nanoseconds GetDeviceClockTime(DeviceBase *device)
-{
-    using std::chrono::seconds;
-    using std::chrono::nanoseconds;
-
-    auto ns = nanoseconds{seconds{device->SamplesDone}} / device->Frequency;
-    return device->ClockBase + ns;
-}
+inline std::chrono::nanoseconds GetDeviceClockTime(const DeviceBase *device) noexcept
+{ return device->getClockTime(); }
 
 /* Helper to get the device latency from the backend, including any fixed
  * latency from post-processing.

core/device.cpp

@@ -9,6 +9,9 @@
 #include "mastering.h"
 
 
+static_assert(std::atomic<std::chrono::nanoseconds>::is_always_lock_free);
+
+
 al::FlexArray<ContextBase*> DeviceBase::sEmptyContextArray{0u};
 
 

core/device.h

@@ -218,8 +218,8 @@ struct DeviceBase {
      */
     NfcFilter mNFCtrlFilter{};
 
-    uint SamplesDone{0u};
-    std::chrono::nanoseconds ClockBase{0};
+    std::atomic<uint> mSamplesDone{0u};
+    std::atomic<std::chrono::nanoseconds> mClockBase{std::chrono::nanoseconds{}};
     std::chrono::nanoseconds FixedLatency{0};
 
     AmbiRotateMatrix mAmbiRotateMatrix{};
@@ -307,6 +307,20 @@ struct DeviceBase {
         return refcount;
     }
 
+    /**
+     * Helper to get the current clock time from the device's ClockBase, and
+     * SamplesDone converted from the sample rate. Should only be called while
+     * watching the MixCount.
+     */
+    std::chrono::nanoseconds getClockTime() const noexcept
+    {
+        using std::chrono::seconds;
+        using std::chrono::nanoseconds;
+
+        auto ns = nanoseconds{seconds{mSamplesDone.load(std::memory_order_relaxed)}} / Frequency;
+        return mClockBase.load(std::memory_order_relaxed) + ns;
+    }
+
     void ProcessHrtf(const size_t SamplesToDo);
     void ProcessAmbiDec(const size_t SamplesToDo);
     void ProcessAmbiDecStablized(const size_t SamplesToDo);