[libc][NFC] Rename RPC opcodes to better reflect their usage

jhuber6 · jhuber6 · commit a6ef0debb1d6 · 2024-12-02T15:35:08.000-06:00
Summary:
RPC_ is a generic prefix here, use LIBC_ to indicate that these are
opcodes used to implement the C library
diff --git a/libc/shared/rpc_opcodes.h b/libc/shared/rpc_opcodes.h
@@ -15,37 +15,37 @@
 #define LLVM_LIBC_OPCODE(n) (LLVM_LIBC_RPC_BASE << 24 | n)
 
 typedef enum {
-  RPC_NOOP = LLVM_LIBC_OPCODE(0),
-  RPC_EXIT = LLVM_LIBC_OPCODE(1),
-  RPC_WRITE_TO_STDOUT = LLVM_LIBC_OPCODE(2),
-  RPC_WRITE_TO_STDERR = LLVM_LIBC_OPCODE(3),
-  RPC_WRITE_TO_STREAM = LLVM_LIBC_OPCODE(4),
-  RPC_WRITE_TO_STDOUT_NEWLINE = LLVM_LIBC_OPCODE(5),
-  RPC_READ_FROM_STREAM = LLVM_LIBC_OPCODE(6),
-  RPC_READ_FGETS = LLVM_LIBC_OPCODE(7),
-  RPC_OPEN_FILE = LLVM_LIBC_OPCODE(8),
-  RPC_CLOSE_FILE = LLVM_LIBC_OPCODE(9),
-  RPC_MALLOC = LLVM_LIBC_OPCODE(10),
-  RPC_FREE = LLVM_LIBC_OPCODE(11),
-  RPC_HOST_CALL = LLVM_LIBC_OPCODE(12),
-  RPC_ABORT = LLVM_LIBC_OPCODE(13),
-  RPC_FEOF = LLVM_LIBC_OPCODE(14),
-  RPC_FERROR = LLVM_LIBC_OPCODE(15),
-  RPC_CLEARERR = LLVM_LIBC_OPCODE(16),
-  RPC_FSEEK = LLVM_LIBC_OPCODE(17),
-  RPC_FTELL = LLVM_LIBC_OPCODE(18),
-  RPC_FFLUSH = LLVM_LIBC_OPCODE(19),
-  RPC_UNGETC = LLVM_LIBC_OPCODE(20),
-  RPC_PRINTF_TO_STDOUT = LLVM_LIBC_OPCODE(21),
-  RPC_PRINTF_TO_STDERR = LLVM_LIBC_OPCODE(22),
-  RPC_PRINTF_TO_STREAM = LLVM_LIBC_OPCODE(23),
-  RPC_PRINTF_TO_STDOUT_PACKED = LLVM_LIBC_OPCODE(24),
-  RPC_PRINTF_TO_STDERR_PACKED = LLVM_LIBC_OPCODE(25),
-  RPC_PRINTF_TO_STREAM_PACKED = LLVM_LIBC_OPCODE(26),
-  RPC_REMOVE = LLVM_LIBC_OPCODE(27),
-  RPC_RENAME = LLVM_LIBC_OPCODE(28),
-  RPC_SYSTEM = LLVM_LIBC_OPCODE(29),
-  RPC_LAST = 0xFFFFFFFF,
+  LIBC_NOOP = LLVM_LIBC_OPCODE(0),
+  LIBC_EXIT = LLVM_LIBC_OPCODE(1),
+  LIBC_WRITE_TO_STDOUT = LLVM_LIBC_OPCODE(2),
+  LIBC_WRITE_TO_STDERR = LLVM_LIBC_OPCODE(3),
+  LIBC_WRITE_TO_STREAM = LLVM_LIBC_OPCODE(4),
+  LIBC_WRITE_TO_STDOUT_NEWLINE = LLVM_LIBC_OPCODE(5),
+  LIBC_READ_FROM_STREAM = LLVM_LIBC_OPCODE(6),
+  LIBC_READ_FGETS = LLVM_LIBC_OPCODE(7),
+  LIBC_OPEN_FILE = LLVM_LIBC_OPCODE(8),
+  LIBC_CLOSE_FILE = LLVM_LIBC_OPCODE(9),
+  LIBC_MALLOC = LLVM_LIBC_OPCODE(10),
+  LIBC_FREE = LLVM_LIBC_OPCODE(11),
+  LIBC_HOST_CALL = LLVM_LIBC_OPCODE(12),
+  LIBC_ABORT = LLVM_LIBC_OPCODE(13),
+  LIBC_FEOF = LLVM_LIBC_OPCODE(14),
+  LIBC_FERROR = LLVM_LIBC_OPCODE(15),
+  LIBC_CLEARERR = LLVM_LIBC_OPCODE(16),
+  LIBC_FSEEK = LLVM_LIBC_OPCODE(17),
+  LIBC_FTELL = LLVM_LIBC_OPCODE(18),
+  LIBC_FFLUSH = LLVM_LIBC_OPCODE(19),
+  LIBC_UNGETC = LLVM_LIBC_OPCODE(20),
+  LIBC_PRINTF_TO_STDOUT = LLVM_LIBC_OPCODE(21),
+  LIBC_PRINTF_TO_STDERR = LLVM_LIBC_OPCODE(22),
+  LIBC_PRINTF_TO_STREAM = LLVM_LIBC_OPCODE(23),
+  LIBC_PRINTF_TO_STDOUT_PACKED = LLVM_LIBC_OPCODE(24),
+  LIBC_PRINTF_TO_STDERR_PACKED = LLVM_LIBC_OPCODE(25),
+  LIBC_PRINTF_TO_STREAM_PACKED = LLVM_LIBC_OPCODE(26),
+  LIBC_REMOVE = LLVM_LIBC_OPCODE(27),
+  LIBC_RENAME = LLVM_LIBC_OPCODE(28),
+  LIBC_SYSTEM = LLVM_LIBC_OPCODE(29),
+  LIBC_LAST = 0xFFFFFFFF,
 } rpc_opcode_t;
 
 #undef LLVM_LIBC_OPCODE
diff --git a/libc/src/__support/GPU/allocator.cpp b/libc/src/__support/GPU/allocator.cpp
@@ -17,7 +17,7 @@ namespace {
 
 void *rpc_allocate(uint64_t size) {
   void *ptr = nullptr;
-  rpc::Client::Port port = rpc::client.open<RPC_MALLOC>();
+  rpc::Client::Port port = rpc::client.open<LIBC_MALLOC>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) { buffer->data[0] = size; },
       [&](rpc::Buffer *buffer, uint32_t) {
@@ -28,7 +28,7 @@ void *rpc_allocate(uint64_t size) {
 }
 
 void rpc_free(void *ptr) {
-  rpc::Client::Port port = rpc::client.open<RPC_FREE>();
+  rpc::Client::Port port = rpc::client.open<LIBC_FREE>();
   port.send([=](rpc::Buffer *buffer, uint32_t) {
     buffer->data[0] = reinterpret_cast<uintptr_t>(ptr);
   });
diff --git a/libc/src/__support/OSUtil/gpu/exit.cpp b/libc/src/__support/OSUtil/gpu/exit.cpp
@@ -18,7 +18,7 @@ namespace internal {
 
 [[noreturn]] void exit(int status) {
   // We want to first make sure the server is listening before we exit.
-  rpc::Client::Port port = rpc::client.open<RPC_EXIT>();
+  rpc::Client::Port port = rpc::client.open<LIBC_EXIT>();
   port.send_and_recv([](rpc::Buffer *, uint32_t) {},
                      [](rpc::Buffer *, uint32_t) {});
   port.send([&](rpc::Buffer *buffer, uint32_t) {
diff --git a/libc/src/__support/OSUtil/gpu/io.cpp b/libc/src/__support/OSUtil/gpu/io.cpp
@@ -15,7 +15,7 @@
 namespace LIBC_NAMESPACE_DECL {
 
 void write_to_stderr(cpp::string_view msg) {
-  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDERR>();
+  rpc::Client::Port port = rpc::client.open<LIBC_WRITE_TO_STDERR>();
   port.send_n(msg.data(), msg.size());
   port.recv([](rpc::Buffer *, uint32_t) { /* void */ });
   port.close();
diff --git a/libc/src/gpu/rpc_host_call.cpp b/libc/src/gpu/rpc_host_call.cpp
@@ -19,7 +19,7 @@ namespace LIBC_NAMESPACE_DECL {
 // arguments. We expect that the pointer here is a valid pointer on the server.
 LLVM_LIBC_FUNCTION(unsigned long long, rpc_host_call,
                    (void *fn, void *data, size_t size)) {
-  rpc::Client::Port port = rpc::client.open<RPC_HOST_CALL>();
+  rpc::Client::Port port = rpc::client.open<LIBC_HOST_CALL>();
   port.send_n(data, size);
   port.send([=](rpc::Buffer *buffer, uint32_t) {
     buffer->data[0] = reinterpret_cast<uintptr_t>(fn);
diff --git a/libc/src/stdio/gpu/clearerr.cpp b/libc/src/stdio/gpu/clearerr.cpp
@@ -15,7 +15,7 @@
 namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(void, clearerr, (::FILE * stream)) {
-  rpc::Client::Port port = rpc::client.open<RPC_CLEARERR>();
+  rpc::Client::Port port = rpc::client.open<LIBC_CLEARERR>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/fclose.cpp b/libc/src/stdio/gpu/fclose.cpp
@@ -18,7 +18,7 @@ namespace LIBC_NAMESPACE_DECL {
 LLVM_LIBC_FUNCTION(int, fclose, (::FILE * stream)) {
   uint64_t ret = 0;
   uintptr_t file = reinterpret_cast<uintptr_t>(stream);
-  rpc::Client::Port port = rpc::client.open<RPC_CLOSE_FILE>();
+  rpc::Client::Port port = rpc::client.open<LIBC_CLOSE_FILE>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) { buffer->data[0] = file; },
       [&](rpc::Buffer *buffer, uint32_t) { ret = buffer->data[0]; });
diff --git a/libc/src/stdio/gpu/feof.cpp b/libc/src/stdio/gpu/feof.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, feof, (::FILE * stream)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_FEOF>();
+  rpc::Client::Port port = rpc::client.open<LIBC_FEOF>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/ferror.cpp b/libc/src/stdio/gpu/ferror.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, ferror, (::FILE * stream)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_FERROR>();
+  rpc::Client::Port port = rpc::client.open<LIBC_FERROR>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/fflush.cpp b/libc/src/stdio/gpu/fflush.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, fflush, (::FILE * stream)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_FFLUSH>();
+  rpc::Client::Port port = rpc::client.open<LIBC_FFLUSH>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/fgets.cpp b/libc/src/stdio/gpu/fgets.cpp
@@ -26,7 +26,7 @@ LLVM_LIBC_FUNCTION(char *, fgets,
 
   uint64_t recv_size;
   void *buf = nullptr;
-  rpc::Client::Port port = rpc::client.open<RPC_READ_FGETS>();
+  rpc::Client::Port port = rpc::client.open<LIBC_READ_FGETS>();
   port.send([=](rpc::Buffer *buffer, uint32_t) {
     buffer->data[0] = count;
     buffer->data[1] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/file.h b/libc/src/stdio/gpu/file.h
@@ -54,7 +54,7 @@ LIBC_INLINE uint64_t write_impl(::FILE *file, const void *data, size_t size) {
   uint64_t ret = 0;
   rpc::Client::Port port = rpc::client.open<opcode>();
 
-  if constexpr (opcode == RPC_WRITE_TO_STREAM) {
+  if constexpr (opcode == LIBC_WRITE_TO_STREAM) {
     port.send([&](rpc::Buffer *buffer, uint32_t) {
       buffer->data[0] = reinterpret_cast<uintptr_t>(file);
     });
@@ -70,17 +70,17 @@ LIBC_INLINE uint64_t write_impl(::FILE *file, const void *data, size_t size) {
 
 LIBC_INLINE uint64_t write(::FILE *f, const void *data, size_t size) {
   if (f == stdout)
-    return write_impl<RPC_WRITE_TO_STDOUT>(f, data, size);
+    return write_impl<LIBC_WRITE_TO_STDOUT>(f, data, size);
   else if (f == stderr)
-    return write_impl<RPC_WRITE_TO_STDERR>(f, data, size);
+    return write_impl<LIBC_WRITE_TO_STDERR>(f, data, size);
   else
-    return write_impl<RPC_WRITE_TO_STREAM>(f, data, size);
+    return write_impl<LIBC_WRITE_TO_STREAM>(f, data, size);
 }
 
 LIBC_INLINE uint64_t read_from_stream(::FILE *file, void *buf, size_t size) {
   uint64_t ret = 0;
   uint64_t recv_size;
-  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STREAM>();
+  rpc::Client::Port port = rpc::client.open<LIBC_READ_FROM_STREAM>();
   port.send([=](rpc::Buffer *buffer, uint32_t) {
     buffer->data[0] = size;
     buffer->data[1] = from_stream(file);
diff --git a/libc/src/stdio/gpu/fopen.cpp b/libc/src/stdio/gpu/fopen.cpp
@@ -18,7 +18,7 @@ namespace LIBC_NAMESPACE_DECL {
 LLVM_LIBC_FUNCTION(::FILE *, fopen,
                    (const char *__restrict path, const char *__restrict mode)) {
   uintptr_t file;
-  rpc::Client::Port port = rpc::client.open<RPC_OPEN_FILE>();
+  rpc::Client::Port port = rpc::client.open<LIBC_OPEN_FILE>();
   port.send_n(path, internal::string_length(path) + 1);
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
diff --git a/libc/src/stdio/gpu/fseek.cpp b/libc/src/stdio/gpu/fseek.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, fseek, (::FILE * stream, long offset, int whence)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_FSEEK>();
+  rpc::Client::Port port = rpc::client.open<LIBC_FSEEK>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/ftell.cpp b/libc/src/stdio/gpu/ftell.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(long, ftell, (::FILE * stream)) {
   long ret;
-  rpc::Client::Port port = rpc::client.open<RPC_FSEEK>();
+  rpc::Client::Port port = rpc::client.open<LIBC_FSEEK>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = file::from_stream(stream);
diff --git a/libc/src/stdio/gpu/puts.cpp b/libc/src/stdio/gpu/puts.cpp
@@ -18,7 +18,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {
   cpp::string_view str_view(str);
-  auto written = file::write_impl<RPC_WRITE_TO_STDOUT_NEWLINE>(stdout, str,
+  auto written = file::write_impl<LIBC_WRITE_TO_STDOUT_NEWLINE>(stdout, str,
                                                                str_view.size());
   if (written != str_view.size() + 1)
     return EOF;
diff --git a/libc/src/stdio/gpu/remove.cpp b/libc/src/stdio/gpu/remove.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, remove, (const char *path)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_REMOVE>();
+  rpc::Client::Port port = rpc::client.open<LIBC_REMOVE>();
   port.send_n(path, internal::string_length(path) + 1);
   port.recv([&](rpc::Buffer *buffer, uint32_t) {
     ret = static_cast<int>(buffer->data[0]);
diff --git a/libc/src/stdio/gpu/rename.cpp b/libc/src/stdio/gpu/rename.cpp
@@ -17,7 +17,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, rename, (const char *oldpath, const char *newpath)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_RENAME>();
+  rpc::Client::Port port = rpc::client.open<LIBC_RENAME>();
   port.send_n(oldpath, internal::string_length(oldpath) + 1);
   port.send_n(newpath, internal::string_length(newpath) + 1);
   port.recv([&](rpc::Buffer *buffer, uint32_t) {
diff --git a/libc/src/stdio/gpu/ungetc.cpp b/libc/src/stdio/gpu/ungetc.cpp
@@ -16,7 +16,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, ungetc, (int c, ::FILE *stream)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_UNGETC>();
+  rpc::Client::Port port = rpc::client.open<LIBC_UNGETC>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer, uint32_t) {
         buffer->data[0] = c;
diff --git a/libc/src/stdio/gpu/vfprintf_utils.h b/libc/src/stdio/gpu/vfprintf_utils.h
@@ -23,8 +23,8 @@ LIBC_INLINE int vfprintf_impl(::FILE *__restrict file,
   uint64_t mask = gpu::get_lane_mask();
   rpc::Client::Port port = rpc::client.open<opcode>();
 
-  if constexpr (opcode == RPC_PRINTF_TO_STREAM ||
-                opcode == RPC_PRINTF_TO_STREAM_PACKED) {
+  if constexpr (opcode == LIBC_PRINTF_TO_STREAM ||
+                opcode == LIBC_PRINTF_TO_STREAM_PACKED) {
     port.send([&](rpc::Buffer *buffer, uint32_t) {
       buffer->data[0] = reinterpret_cast<uintptr_t>(file);
     });
@@ -63,24 +63,24 @@ LIBC_INLINE int vfprintf_internal(::FILE *__restrict stream,
   // separate opcode so the server knows how much to advance the pointers.
 #if defined(LIBC_TARGET_ARCH_IS_AMDGPU)
   if (stream == stdout)
-    return vfprintf_impl<RPC_PRINTF_TO_STDOUT_PACKED>(stream, format,
-                                                      format_size, vlist);
+    return vfprintf_impl<LIBC_PRINTF_TO_STDOUT_PACKED>(stream, format,
+                                                       format_size, vlist);
   else if (stream == stderr)
-    return vfprintf_impl<RPC_PRINTF_TO_STDERR_PACKED>(stream, format,
-                                                      format_size, vlist);
+    return vfprintf_impl<LIBC_PRINTF_TO_STDERR_PACKED>(stream, format,
+                                                       format_size, vlist);
   else
-    return vfprintf_impl<RPC_PRINTF_TO_STREAM_PACKED>(stream, format,
-                                                      format_size, vlist);
+    return vfprintf_impl<LIBC_PRINTF_TO_STREAM_PACKED>(stream, format,
+                                                       format_size, vlist);
 #else
   if (stream == stdout)
-    return vfprintf_impl<RPC_PRINTF_TO_STDOUT>(stream, format, format_size,
-                                               vlist);
+    return vfprintf_impl<LIBC_PRINTF_TO_STDOUT>(stream, format, format_size,
+                                                vlist);
   else if (stream == stderr)
-    return vfprintf_impl<RPC_PRINTF_TO_STDERR>(stream, format, format_size,
-                                               vlist);
+    return vfprintf_impl<LIBC_PRINTF_TO_STDERR>(stream, format, format_size,
+                                                vlist);
   else
-    return vfprintf_impl<RPC_PRINTF_TO_STREAM>(stream, format, format_size,
-                                               vlist);
+    return vfprintf_impl<LIBC_PRINTF_TO_STREAM>(stream, format, format_size,
+                                                vlist);
 #endif
 }
 
diff --git a/libc/src/stdlib/gpu/abort.cpp b/libc/src/stdlib/gpu/abort.cpp
@@ -17,7 +17,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(void, abort, ()) {
   // We want to first make sure the server is listening before we abort.
-  rpc::Client::Port port = rpc::client.open<RPC_ABORT>();
+  rpc::Client::Port port = rpc::client.open<LIBC_ABORT>();
   port.send_and_recv([](rpc::Buffer *, uint32_t) {},
                      [](rpc::Buffer *, uint32_t) {});
   port.send([&](rpc::Buffer *, uint32_t) {});
diff --git a/libc/src/stdlib/gpu/system.cpp b/libc/src/stdlib/gpu/system.cpp
@@ -17,7 +17,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, system, (const char *command)) {
   int ret;
-  rpc::Client::Port port = rpc::client.open<RPC_SYSTEM>();
+  rpc::Client::Port port = rpc::client.open<LIBC_SYSTEM>();
   port.send_n(command, internal::string_length(command) + 1);
   port.recv([&](rpc::Buffer *buffer, uint32_t) {
     ret = static_cast<int>(buffer->data[0]);
diff --git a/libc/test/integration/startup/gpu/rpc_test.cpp b/libc/test/integration/startup/gpu/rpc_test.cpp
@@ -35,7 +35,7 @@ static void test_add_simple() {
 // Test to ensure that the RPC mechanism doesn't hang on divergence.
 static void test_noop(uint8_t data) {
   LIBC_NAMESPACE::rpc::Client::Port port =
-      LIBC_NAMESPACE::rpc::client.open<RPC_NOOP>();
+      LIBC_NAMESPACE::rpc::client.open<LIBC_NOOP>();
   port.send([=](LIBC_NAMESPACE::rpc::Buffer *buffer, uint32_t) {
     buffer->data[0] = data;
   });
diff --git a/libc/utils/gpu/loader/Loader.h b/libc/utils/gpu/loader/Loader.h
@@ -168,13 +168,13 @@ inline uint32_t handle_server(rpc::Server &server, uint32_t index,
     port->recv([&](rpc::Buffer *, uint32_t) {});
     break;
   }
-  case RPC_MALLOC: {
+  case LIBC_MALLOC: {
     port->recv_and_send([&](rpc::Buffer *buffer, uint32_t) {
       buffer->data[0] = reinterpret_cast<uintptr_t>(alloc(buffer->data[0]));
     });
     break;
   }
-  case RPC_FREE: {
+  case LIBC_FREE: {
     port->recv([&](rpc::Buffer *buffer, uint32_t) {
       free(reinterpret_cast<void *>(buffer->data[0]));
     });
diff --git a/libc/utils/gpu/server/rpc_server.cpp b/libc/utils/gpu/server/rpc_server.cpp
diff --git a/offload/plugins-nextgen/common/src/RPC.cpp b/offload/plugins-nextgen/common/src/RPC.cpp
