[libc] Remove 'try_open' from the client interface

[jhuber6]

Summary

We previously provided the try_open facility to indicate if opening a
port failed. This is used on the server to continuously poll and quit if
there is no work. However the Client currently has no way to recover
from not finding a port and simply spins repeatedly. The abstraction
here costs us some resources. This patch changes the interface to only
allow open on the client side and merges the loops. This saves us a
branch and a good number of registers.

[jhuber6]

Forgot to remove the function

[JonChesterfield]

The can't run out of ports because more are available than hardware resources doesn't really work with fewer ports than hardware resources, but that's an existing problem

[jhuber6]

The hardware resource limit isn't something that's enforced yet. Right now we
just set it to the maximum amount of memory we allocate, which is 512. I believe
most GPUs will need more like 2048 to cover all hardware resources. We'll work
on that later once we have a smarter port allocation scheme. For now we would
probablyt replace the initialize at zero with the sm-id as a cheap way to
stagger them out. The smid can change during execution so it's not a perfect
solution.

libc/src/__support/RPC/rpc.h

 /// The RPC client used to make requests to the server.
 struct Client {
   LIBC_INLINE Client() = default;
   LIBC_INLINE Client(const Client &) = delete;
   LIBC_INLINE Client &operator=(const Client &) = delete;
   LIBC_INLINE ~Client() = default;
 
   using Port = rpc::Port<false, Packet<gpu::LANE_SIZE>>;
-  template <uint16_t opcode> LIBC_INLINE cpp::optional<Port> try_open();
   template <uint16_t opcode> LIBC_INLINE Port open();
 
   LIBC_INLINE void reset(uint32_t port_count, void *buffer) {
     process.reset(port_count, buffer);
   }
 
 private:
   Process<false, Packet<gpu::LANE_SIZE>> process;
recv([=](Buffer *buffer, uint32_t id) {
                          : lane_value(size, id) - idx;
       if (idx < lane_value(size, id))
         inline_memcpy(advance(lane_value(dst, id), idx), buffer->data, len);
     });
     idx += sizeof(Buffer::data);
   }
 }
 
-/// 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.
-template <uint16_t opcode>
-[[clang::convergent]] LIBC_INLINE cpp::optional<Client::Port>
-Client::try_open() {
-  // Perform a naive linear scan for a port that can be opened to send data.
-  for (uint32_t index = 0; index < process.port_count; ++index) {
+/// Continually 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.
+template <uint16_t opcode> LIBC_INLINE Client::Port Client::open() {
+  // Repeatedly perform a naive linear scan for a port that can be opened to
+  // send data.
+  for (uint32_t index = 0;; ++index) {
+    // Start from the beginning if we run out of ports to check.
+    if (index >= process.port_count)
+      index = 0;
+
     // Attempt to acquire the lock on this index.
     uint64_t lane_mask = gpu::get_lane_mask();
     if (!process.try_lock(lane_mask, index))
       continue;
 
     uint32_t in = process.load_inbox(index);
     uint32_t out = process.load_outbox(index);
 
     // Once we acquire the index we need to check if we are in a valid sending
     // state.
     if (process.buffer_unavailable(in, out)) {
       process.unlock(lane_mask, index);
       continue;
     }
 
     if (is_first_lane(lane_mask)) {
       process.packet[index].header.opcode = opcode;
       process.packet[index].header.mask = lane_mask;
     }
     gpu::sync_lane(lane_mask);
     return Port(process, lane_mask, index, out);
   }
-  return cpp::nullopt;
-}
-
-template <uint16_t opcode> LIBC_INLINE Client::Port Client::open() {
-  for (;;) {
-    if (cpp::optional<Client::Port> p = try_open<opcode>())
-      return cpp::move(p.value());
-    sleep_briefly();
-  }
 }
 
 /// Attempts to open a port to use as the server. The server can only open a
 /// port if it has a pending receive operation
 template <uint32_t lane_size>
 [[clang::convergent]] LIBC_INLINE
     cpp::optional<typename Server<lane_size>::Port>
     Server<lane_size>::try_open() {