[libc][rpc] Fold can send/recv into buffer_unavailable

[JonChesterfield]

Summary

Left out of D149788 to simplify the diff

[jhuber6]

I actually like the named function for this operation, it makes it much more readable. How about can_use_buffer or similar.

[JonChesterfield]

It's always used negated, buffer_unavailable?

[jhuber6]

In D149807#4317567, @JonChesterfield wrote:

It's always used negated, buffer_unavailable?

Works for me

[JonChesterfield]

• name the operation

[JonChesterfield]

• with Process annotation

[JonChesterfield]

-rebase

[JonChesterfield]

rebase

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 owns the buffer for a send.
-  LIBC_INLINE static bool can_send_data(uint32_t in, uint32_t out) {
-    return in == out;
-  }
-
-  /// Determines if this process owns the buffer for a receive.
-  LIBC_INLINE static bool can_recv_data(uint32_t in, uint32_t out) {
-    return in == out;
+  /// 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;
   }
 };
 
 /// 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.
struct Server : public Process<true> {
   LIBC_INLINE Port open();
 };
 
 /// Applies \p fill to the shared buffer and initiates a send operation.
 template <bool T> template <typename F> LIBC_INLINE void Port<T>::send(F fill) {
   uint32_t in = process.load_inbox(index);
 
   // We need to wait until we own the buffer before sending.
-  while (!Process<T>::can_send_data(in, out)) {
+  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.
   fill(&process.buffer[index]);
   out = !out;
   atomic_thread_fence(cpp::MemoryOrder::RELEASE);
   process.outbox[index].store(out, cpp::MemoryOrder::RELAXED);
 }
 
 /// 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>::can_recv_data(in, out)) {
+  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.
   use(&process.buffer[index]);
   out = !out;
LIBC_INLINE cpp::optional<Client::Port> Client::try_open(uint16_t opcode) {
   // 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 (!can_send_data(in, out)) {
+
+  if (buffer_unavailable(in, out)) {
     lock[index].store(0, cpp::MemoryOrder::RELAXED);
     return cpp::nullopt;
   }
 
   buffer->opcode = opcode;
   return Port(*this, index, out);
 }
 

 /// port if it has a pending receive operation
 LIBC_INLINE cpp::optional<Server::Port> Server::try_open() {
   constexpr uint64_t index = 0;
   uint32_t in = load_inbox(index);
   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 (!can_recv_data(in, out))
+  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))
     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 (!can_recv_data(in, out)) {
+  if (buffer_unavailable(in, out)) {
     lock[index].store(0, cpp::MemoryOrder::RELAXED);
     return cpp::nullopt;
   }
 
   return Port(*this, index, out);
 }
 
 LIBC_INLINE Server::Port Server::open() {