[libc][rpc] Factor try_lock, unlock into functions on Process

[JonChesterfield]

Summary

Reduces line noise and localises changes needed for volta

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;
   }
 
-  /// Determines if this process needs to wait for ownership of the buffer
+  /// 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.
+  /// The lock is held when the zeroth bit of the uint32_t at lock[index]
+  /// is set, and available when that bit is clear. Bits [1, 32) are zero.
+  /// Or with one is a no-op when the lock is already held.
+  LIBC_INLINE bool try_lock(uint64_t index) {
+    return lock[index].fetch_or(1, cpp::MemoryOrder::RELAXED) == 0;
+  }
+
+  // Unlock the lock at index.
+  LIBC_INLINE void unlock(uint64_t index) {
+    lock[index].store(0, cpp::MemoryOrder::RELAXED);
+  }
 };
 
 /// The port provides the interface to communicate between the multiple
 /// processes. A port is conceptually an index into the memory provided by the
 /// underlying process that is guarded by a lock bit.
 template <bool T> struct Port {
   // TODO: This should be move-only.
   LIBC_INLINE Port(Process<T> &process, uint64_t index, uint32_t out)
template <bool T> struct Port {
   template <typename W> LIBC_INLINE void recv_and_send(W work);
   LIBC_INLINE void send_n(const void *src, uint64_t size);
   template <typename A> LIBC_INLINE void recv_n(A alloc);
 
   LIBC_INLINE uint16_t get_opcode() const {
     return process.buffer[index].opcode;
   }
 
-  LIBC_INLINE void close() {
-    process.lock[index].store(0, cpp::MemoryOrder::RELAXED);
-  }
+  LIBC_INLINE void close() { process.unlock(index); }
 
 private:
   Process<T> &process;
   uint64_t index;
   uint32_t out;
 };
 
 /// The RPC client used to make requests to the server.

 
 /// Attempts to open a port to use as the client. The client can only open a
 /// port if we find an index that is in a valid sending state. That is, there
 /// are send operations pending that haven't been serviced on this port. Each
 /// port instance uses an associated \p opcode to tell the server what to do.
 LIBC_INLINE cpp::optional<Client::Port> Client::try_open(uint16_t opcode) {
   constexpr uint64_t index = 0;
   // Attempt to acquire the lock on this index.
-  if (lock[index].fetch_or(1, cpp::MemoryOrder::RELAXED))
+  if (!try_lock(index))
     return cpp::nullopt;
 
   // 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);
 
   // Once we acquire the index we need to check if we are in a valid sending
   // state.
 
   if (buffer_unavailable(in, out)) {
-    lock[index].store(0, cpp::MemoryOrder::RELAXED);
+    unlock(index);
     return cpp::nullopt;
   }
 
   buffer->opcode = opcode;
   return Port(*this, index, out);
 }
 
 LIBC_INLINE Client::Port Client::open(uint16_t opcode) {
LIBC_INLINE cpp::optional<Server::Port> Server::try_open() {
   uint32_t out = outbox[index].load(cpp::MemoryOrder::RELAXED);
 
   // The server is passive, if there is no work pending don't bother
   // opening a port.
   if (buffer_unavailable(in, out))
     return cpp::nullopt;
 
   // Attempt to acquire the lock on this index.
-  if (lock[index].fetch_or(1, cpp::MemoryOrder::RELAXED))
+  if (!try_lock(index))
     return cpp::nullopt;
 
   // 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);
 
   if (buffer_unavailable(in, out)) {
-    lock[index].store(0, cpp::MemoryOrder::RELAXED);
+    unlock(index);
     return cpp::nullopt;
   }
 
   return Port(*this, index, out);
 }
 
 LIBC_INLINE Server::Port Server::open() {
   for (;;) {