perf: relax EpochLock memory ordering from seq_cst to acquire/release

The epoch counter is used to detect if meshing occurred during a
lock-free operation. Sequential consistency is stronger than needed.

The correctness argument:
- Writers (meshing thread) use release ordering when incrementing the
  epoch, ensuring all prior/subsequent meshing work is properly ordered
- Readers use acquire ordering, ensuring they see all meshing work
  that happened before the release store they observe
- Additionally, mprotect() on source pages during meshing provides a
  hard barrier that catches any actual data races

This is safe because:
1. There's only one writer (meshing thread holds all locks)
2. If a reader doesn't see an epoch change, either meshing hasn't
   started, or the reader's work is on unrelated data
3. If the reader's work would conflict with meshing, mprotect causes
   a fault that synchronizes the threads

No performance change expected on x86 (already uses acquire/release
for seq_cst atomics), but may improve performance on ARM/POWER.

Author: bpowers

src/global_heap.h

@@ -41,26 +41,32 @@ class EpochLock {
   }
 
   inline size_t ATTRIBUTE_ALWAYS_INLINE current() const noexcept {
-    return _epoch.load(std::memory_order::memory_order_seq_cst);
+    // Acquire ordering: if we read a value stored with release, we see all
+    // operations that happened-before that store. This ensures readers see
+    // all meshing work that completed before the epoch was updated.
+    return _epoch.load(std::memory_order_acquire);
   }
 
   inline size_t ATTRIBUTE_ALWAYS_INLINE isSame(size_t startEpoch) const noexcept {
     return current() == startEpoch;
   }
 
   inline void ATTRIBUTE_ALWAYS_INLINE lock() noexcept {
-    // make sure that the previous epoch was even
-    const auto old = _epoch.fetch_add(1, std::memory_order::memory_order_seq_cst);
+    // Release ordering: all subsequent meshing operations will be ordered
+    // after this store. Readers with acquire loads will see this update.
+    // The old value is only used for assertion, so relaxed read is fine.
+    const auto old = _epoch.fetch_add(1, std::memory_order_release);
     hard_assert(old % 2 == 0);
   }
 
   inline void ATTRIBUTE_ALWAYS_INLINE unlock() noexcept {
+    // Release ordering: all prior meshing operations are ordered before this
+    // store. Readers with acquire loads will see all meshing work completed.
 #ifndef NDEBUG
-    // make sure that the previous epoch was odd
-    const auto old = _epoch.fetch_add(1, std::memory_order::memory_order_seq_cst);
+    const auto old = _epoch.fetch_add(1, std::memory_order_release);
     d_assert(old % 2 == 1);
 #else
-    _epoch.fetch_add(1, std::memory_order::memory_order_seq_cst);
+    _epoch.fetch_add(1, std::memory_order_release);
 #endif
   }