[libc][rpc][nfc] Encapsulate access to outbox pointer

[JonChesterfield]

• comments

[JonChesterfield]

• postpone private annotation, interacts badly with reset

libc/src/__support/RPC/rpc.h

template <bool InvertInbox> struct Process {
   /// races result. If either inbox or outbox is inverted for one process, that
   /// process interprets memory as Inbox!=Outbox and thus waits for the other.
   /// It is simpler to invert reads from the inbox than writes to the outbox.
   LIBC_INLINE uint32_t load_inbox(uint64_t index) {
     uint32_t i = inbox[index].load(cpp::MemoryOrder::RELAXED);
     return InvertInbox ? !i : i;
   }
 
+  /// Retrieve the outbox state from memory shared between processes.
+  /// Never needs to invert the associated read.
+  LIBC_INLINE uint32_t load_outbox(uint64_t index) {
+    return outbox[index].load(cpp::MemoryOrder::RELAXED);
+  }
+
+  /// Signal to the other process that this one is finished with the buffer.
+  /// Equivalent to loading outbox followed by store of the inverted value
+  /// The outbox is write only by this warp and tracking the value locally is
+  /// cheaper than calling load_outbox to get the value to store.
+  LIBC_INLINE uint32_t invert_outbox(uint64_t index, uint32_t current_outbox) {
+    uint32_t inverted_outbox = !current_outbox;
+    outbox[index].store(inverted_outbox, cpp::MemoryOrder::RELAXED);
+    return inverted_outbox;
+  }
+
   /// Determines if this process needs to wait for ownership of the buffer.
   LIBC_INLINE static bool buffer_unavailable(uint32_t in, uint32_t out) {
     return in != out;
   }
 
   /// Attempt to claim the lock at index. Return true on lock taken.
   /// lane_mask is a bitmap of the threads in the warp that would hold the
   /// single lock on success, e.g. the result of gpu::get_lane_mask()
template <bool T> template <typename F> LIBC_INLINE void Port<T>::send(F fill) {
   // We need to wait until we own the buffer before sending.
   while (Process<T>::buffer_unavailable(in, out)) {
     sleep_briefly();
     in = process.load_inbox(index);
   }
 
   // Apply the \p fill function to initialize the buffer and release the memory.
   process.invoke_rpc(fill, process.get_packet(index));
-  out = !out;
   atomic_thread_fence(cpp::MemoryOrder::RELEASE);
-  process.outbox[index].store(out, cpp::MemoryOrder::RELAXED);
+  out = process.invert_outbox(index, out);
 }
 
 /// Applies \p use to the shared buffer and acknowledges the send.
 template <bool T> template <typename U> LIBC_INLINE void Port<T>::recv(U use) {
   uint32_t in = process.load_inbox(index);
 
   // We need to wait until we own the buffer before receiving.
   while (Process<T>::buffer_unavailable(in, out)) {
     sleep_briefly();
     in = process.load_inbox(index);
   }
   atomic_thread_fence(cpp::MemoryOrder::ACQUIRE);
 
   // Apply the \p use function to read the memory out of the buffer.
   process.invoke_rpc(use, process.get_packet(index));
-  out = !out;
-  process.outbox[index].store(out, cpp::MemoryOrder::RELAXED);
+  out = process.invert_outbox(index, out);
 }
 
 /// Combines a send and receive into a single function.
 template <bool T>
 template <typename F, typename U>
 LIBC_INLINE void Port<T>::send_and_recv(F fill, U use) {
   send(fill);
   recv(use);
for (uint64_t index = 0; index < port_count; ++index) {
     uint64_t lane_mask = gpu::get_lane_mask();
     if (!try_lock(lane_mask, index))
       continue;
 
     // The mailbox state must be read with the lock held.
     atomic_thread_fence(cpp::MemoryOrder::ACQUIRE);
 
     uint32_t in = load_inbox(index);
-    uint32_t out = outbox[index].load(cpp::MemoryOrder::RELAXED);
+    uint32_t out = load_outbox(index);
 
     // Once we acquire the index we need to check if we are in a valid sending
     // state.
     if (buffer_unavailable(in, out)) {
       unlock(lane_mask, index);
       continue;
     }
 

 
 /// Attempts to open a port to use as the server. The server can only open a
 /// port if it has a pending receive operation
 [[clang::convergent]] LIBC_INLINE cpp::optional<Server::Port>
 Server::try_open() {
   // Perform a naive linear scan for a port that has a pending request.
   for (uint64_t index = 0; index < port_count; ++index) {
     uint32_t in = load_inbox(index);
-    uint32_t out = outbox[index].load(cpp::MemoryOrder::RELAXED);
+    uint32_t out = load_outbox(index);
 
     // The server is passive, if there is no work pending don't bother
     // opening a port.
     if (buffer_unavailable(in, out))
       continue;
 
     // Attempt to acquire the lock on this index.
     uint64_t lane_mask = gpu::get_lane_mask();
     // Attempt to acquire the lock on this index.
     if (!try_lock(lane_mask, index))
       continue;
 
     // The mailbox state must be read with the lock held.
     atomic_thread_fence(cpp::MemoryOrder::ACQUIRE);
 
     in = load_inbox(index);
-    out = outbox[index].load(cpp::MemoryOrder::RELAXED);
+    out = load_outbox(index);
 
     if (buffer_unavailable(in, out)) {
       unlock(lane_mask, index);
       continue;
     }
 
     return Port(*this, lane_mask, index, out);
   }