[libc] Instantiate and sanity check rpc class

[JonChesterfield]

Summary

CMake plumbing cargo culted from other tests.
Minor changes to Process to allow statically allocating a buffer.

[jhuber6]

The CMake looks good, losing protected is fine since these are pretty harmless methods. This will run on x64 as it stands, so you should try a non-GPU build of libc and see if it still runs and passes.

I had a previous attempt to move the integration tests to the same location but the unit test suite dos not handle multiple threads gracefully.

[jhuber6]

Test passes for me, doesn't run on non-GPU builds because we don't make the RPC dependency, so I think it's good. It might be nice to check the RPC against a CPU client at some point. It is supposed to be a generic solution after all.

[JonChesterfield]

This test doesn't need anything other than the header. If I delete the string after depends it still runs on the gpu, i.e. an empty DEPENDS clause seems to be fine, shall we go with that instead?

Edit: seems not. Lets go with this as it gives me a place to write other tests in a similar style, and we can work out how to enable them on x64 later.

[jhuber6]

In D153594#4443127, @JonChesterfield wrote:

This test doesn't need anything other than the header. If I delete the string after depends it still runs on the gpu, i.e. an empty DEPENDS clause seems to be fine, shall we go with that instead?

I think it running on the GPU only is good for now, we can enable it on the CPU in a separate patch

libc/src/__support/RPC/rpc.h

public:
   /// Allocate a memory buffer sufficient to store the following equivalent
   /// representation in memory.
   ///
   /// struct Equivalent {
   ///   Atomic<uint32_t> primary[port_count];
   ///   Atomic<uint32_t> secondary[port_count];
   ///   Packet buffer[port_count];
   /// };
-  LIBC_INLINE static uint64_t allocation_size(uint64_t port_count) {
+  LIBC_INLINE static constexpr uint64_t allocation_size(uint64_t port_count) {
     return buffer_offset(port_count) + buffer_bytes(port_count);
   }
 
-protected:
   /// Retrieve the inbox state from memory shared between processes.
   LIBC_INLINE uint32_t load_inbox(uint64_t index) {
     return inbox[index].load(cpp::MemoryOrder::RELAXED);
   }
 
   /// Retrieve the outbox state from memory shared between processes.
   LIBC_INLINE uint32_t load_outbox(uint64_t index) {
     return outbox[index].load(cpp::MemoryOrder::RELAXED);
LIBC_INLINE void invoke_rpc(cpp::function<void(Buffer *, uint32_t)> fn,
     } else {
       for (uint32_t i = 0; i < lane_size; i += gpu::get_lane_size())
         if (packet.header.mask & 1ul << i)
           fn(&packet.payload.slot[i], i);
     }
   }
 
   /// Number of bytes to allocate for an inbox or outbox.
-  LIBC_INLINE static uint64_t mailbox_bytes(uint64_t port_count) {
+  LIBC_INLINE static constexpr uint64_t mailbox_bytes(uint64_t port_count) {
     return port_count * sizeof(cpp::Atomic<uint32_t>);
   }
 
   /// Number of bytes to allocate for the buffer containing the packets.
-  LIBC_INLINE static uint64_t buffer_bytes(uint64_t port_count) {
+  LIBC_INLINE static constexpr uint64_t buffer_bytes(uint64_t port_count) {
     return port_count * sizeof(Packet<lane_size>);
   }
 
   /// Offset of the inbox in memory. This is the same as the outbox if inverted.
-  LIBC_INLINE static uint64_t inbox_offset(uint64_t port_count) {
+  LIBC_INLINE static constexpr uint64_t inbox_offset(uint64_t port_count) {
     return Invert ? mailbox_bytes(port_count) : 0;
   }
 
   /// Offset of the outbox in memory. This is the same as the inbox if inverted.
-  LIBC_INLINE static uint64_t outbox_offset(uint64_t port_count) {
+  LIBC_INLINE static constexpr uint64_t outbox_offset(uint64_t port_count) {
     return Invert ? 0 : mailbox_bytes(port_count);
   }
 
   /// Offset of the buffer containing the packets after the inbox and outbox.
-  LIBC_INLINE static uint64_t buffer_offset(uint64_t port_count) {
+  LIBC_INLINE static constexpr uint64_t buffer_offset(uint64_t port_count) {
     return align_up(2 * mailbox_bytes(port_count), alignof(Packet<lane_size>));
   }
 };
 
 /// 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, uint32_t S> struct Port {

libc/src/__support/RPC/rpc_util.h

 #if defined(LIBC_TARGET_ARCH_IS_GPU)
   return true;
 #else
   return false;
 #endif
 }
 
 /// Return \p val aligned "upwards" according to \p align.
-template <typename V, typename A> LIBC_INLINE V align_up(V val, A align) {
+template <typename V, typename A>
+LIBC_INLINE constexpr V align_up(V val, A align) {
   return ((val + V(align) - 1) / V(align)) * V(align);
 }
 
 /// Utility to provide a unified interface between the CPU and GPU's memory
 /// model. On the GPU stack variables are always private to a lane so we can
 /// simply use the variable passed in. On the CPU we need to allocate enough
 /// space for the whole lane and index into it.
 template <typename V> LIBC_INLINE V &lane_value(V *val, uint32_t id) {

libc/test/src/__support/CMakeLists.txt

add_custom_command(TARGET libc_str_to_float_comparison_test
                    POST_BUILD
                    COMMAND $<TARGET_FILE:libc_str_to_float_comparison_test> ${float_test_file}
                    DEPENDS ${float_test_file}
                    COMMENT "Test the strtof and strtod implementations against precomputed results." 
                    VERBATIM)
 
 add_subdirectory(CPP)
 add_subdirectory(File)
+add_subdirectory(RPC)
 add_subdirectory(OSUtil)
 add_subdirectory(FPUtil)

libc/test/src/__support/RPC/CMakeLists.txt

+add_custom_target(libc-rpc-tests)
+
+add_libc_test(
+  rpc_smoke_test
+  SUITE
+    libc-rpc-tests
+  SRCS
+    rpc_smoke_test.cpp
+  DEPENDS
+   libc.src.__support.RPC.rpc
+)

libc/test/src/__support/RPC/rpc_smoke_test.cpp

+//===-- smoke tests for RPC -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/__support/RPC/rpc.h"
+
+#include "test/UnitTest/Test.h"
+
+namespace {
+enum { lane_size = 8, port_count = 4 };
+
+using ProcAType = __llvm_libc::rpc::Process<false, lane_size>;
+using ProcBType = __llvm_libc::rpc::Process<true, lane_size>;
+
+static_assert(ProcAType::inbox_offset(port_count) ==
+              ProcBType::outbox_offset(port_count));
+
+static_assert(ProcAType::outbox_offset(port_count) ==
+              ProcBType::inbox_offset(port_count));
+
+enum { alloc_size = ProcAType::allocation_size(port_count) };
+
+alignas(64) char buffer[alloc_size] = {0};
+} // namespace
+
+TEST(LlvmLibcRPCSmoke, SanityCheck) {
+
+  ProcAType ProcA;
+  ProcBType ProcB;
+
+  ProcA.reset(port_count, buffer);
+  ProcB.reset(port_count, buffer);
+
+  EXPECT_EQ(ProcA.get_buffer_start(), ProcB.get_buffer_start());
+
+  uint64_t index = 0; // any < port_count
+  uint64_t lane_mask = 1;
+
+  // Each process has its own local lock for index
+  EXPECT_TRUE(ProcA.try_lock(lane_mask, index));
+  EXPECT_TRUE(ProcB.try_lock(lane_mask, index));
+
+  // All zero to begin with
+  EXPECT_EQ(ProcA.load_inbox(index), 0u);
+  EXPECT_EQ(ProcB.load_inbox(index), 0u);
+  EXPECT_EQ(ProcA.load_outbox(index), 0u);
+  EXPECT_EQ(ProcB.load_outbox(index), 0u);
+
+  // Available for ProcA and not for ProcB
+  EXPECT_FALSE(ProcA.buffer_unavailable(ProcA.load_inbox(index),
+                                        ProcA.load_outbox(index)));
+  EXPECT_TRUE(ProcB.buffer_unavailable(ProcB.load_inbox(index),
+                                       ProcB.load_outbox(index)));
+
+  // ProcA write to outbox
+  uint32_t ProcAOutbox = ProcA.load_outbox(index);
+  EXPECT_EQ(ProcAOutbox, 0u);
+  ProcAOutbox = ProcA.invert_outbox(index, ProcAOutbox);
+  EXPECT_EQ(ProcAOutbox, 1u);
+
+  // No longer available for ProcA
+  EXPECT_TRUE(ProcA.buffer_unavailable(ProcA.load_inbox(index), ProcAOutbox));
+
+  // Outbox is still zero, hasn't been written to
+  EXPECT_EQ(ProcB.load_outbox(index), 0u);
+
+  // Wait for ownership will terminate because load_inbox returns 1
+  EXPECT_EQ(ProcB.load_inbox(index), 1u);
+  ProcB.wait_for_ownership(index, 0u, 0u);
+
+  // and B now has the buffer available
+  EXPECT_FALSE(ProcB.buffer_unavailable(ProcB.load_inbox(index),
+                                        ProcB.load_outbox(index)));
+
+  // Enough checks for one test, close the locks
+  ProcA.unlock(lane_mask, index);
+  ProcB.unlock(lane_mask, index);
+}