[libc] Add support for the 'fread' function on the GPU

[jhuber6]

Summary

This patch adds support for fread on the GPU via the RPC mechanism.
Here we simply pass the size of the read to the server and then copy it
back to the client via the RPC channel. This should allow us to do the
basic operations on files now. This will obviously be slow for large
sizes due ot the number of RPC calls involved, this could be optimized
further by having a special RPC call that can initiate a memcpy between
the two pointers.

[sivachandra]

libc/test/src/stdio/fopen_test.cpp

23

UPPER_CASE.

33

Typo - new_file? Wonder how this is working at all because file is closed on line 27.

[jhuber6]

Fix test

[jhuber6]

ping

[jdoerfert]

libc/utils/gpu/server/rpc_server.cpp

115

To allow for partial fread. Technically, you should put in exactly what the user put in on the other side. It makes a difference after all.

117

What is this about, I don't get it.

120

I don't get this. We should always return rets[id], no?

[jhuber6]

libc/utils/gpu/server/rpc_server.cpp

117

This is what streams the data read from the CPU buffer to the GPU.

120

I think this is a consequence of me not using the size argument instead of the nmemb argument. Since the return value is supposed to correspond to the size. I can fix it and test.

[jhuber6]

Rebase

[jhuber6]

Fix test again

[jdoerfert]

This is what confused me earlier:
If I read the fread definition properly, libc's implementation is wrong. The read is supposed to be quantized, but in libc it is not (or it is quantized with an element size of 1).

libc/utils/gpu/server/rpc_server.cpp

120

I mean, whatever host fread returns is what we should return. That said, we really need to pass size and nmemb from the device to the host.

[jdoerfert]

In D155121#4535879, @jdoerfert wrote:

This is what confused me earlier:
If I read the fread definition properly, libc's implementation is wrong. The read is supposed to be quantized, but in libc it is not (or it is quantized with an element size of 1).

Turns out, all libc impl. do this... anyway. With 1 as size on the host side this should do what the host would do, so we should be fine.

libc/config/gpu/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.free
 
     # errno.h entrypoints
     libc.src.errno.errno
 
     # stdio.h entrypoints
     libc.src.stdio.puts
     libc.src.stdio.fputs
+    libc.src.stdio.fread
     libc.src.stdio.fclose
     libc.src.stdio.fopen
     libc.src.stdio.stdin
     libc.src.stdio.stdout
     libc.src.stdio.stderr
 
     # inttypes.h entrypoints
     libc.src.inttypes.imaxabs

libc/include/llvm-libc-types/rpc_opcodes_t.h

 #define __LLVM_LIBC_TYPES_RPC_OPCODE_H__
 
 typedef enum : unsigned short {
   RPC_NOOP = 0,
   RPC_EXIT = 1,
   RPC_WRITE_TO_STDOUT = 2,
   RPC_WRITE_TO_STDERR = 3,
   RPC_WRITE_TO_STREAM = 4,
-  RPC_OPEN_FILE = 5,
-  RPC_CLOSE_FILE = 6,
-  RPC_MALLOC = 7,
-  RPC_FREE = 8,
+  RPC_READ_FROM_STDIN = 5,
+  RPC_READ_FROM_STREAM = 6,
+  RPC_OPEN_FILE = 7,
+  RPC_CLOSE_FILE = 8,
+  RPC_MALLOC = 9,
+  RPC_FREE = 10,
   // TODO: Move these out of here and handle then with custom handlers in the
   // loader.
   RPC_TEST_INCREMENT = 1000,
   RPC_TEST_INTERFACE = 1001,
   RPC_TEST_STREAM = 1002,
 } rpc_opcode_t;
 
 #endif // __LLVM_LIBC_TYPES_RPC_OPCODE_H__

libc/src/__support/File/gpu/file.cpp

 
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 namespace {
 
 FileIOResult write_func(File *, const void *, size_t);
+FileIOResult read_func(File *, void *, size_t);
 int close_func(File *);
 
 } // namespace
 
 class GPUFile : public File {
   uintptr_t file;
 
 public:
   constexpr GPUFile(uintptr_t file, File::ModeFlags modeflags)
-      : File(&write_func, nullptr, nullptr, &close_func, nullptr, 0, _IONBF,
+      : File(&write_func, &read_func, nullptr, &close_func, nullptr, 0, _IONBF,
              false, modeflags),
         file(file) {}
 
   uintptr_t get_file() const { return file; }
 };
 
 namespace {
 
else if (gpu_file == stderr)
     ret = write_to_stderr(data, size);
   else
     ret = write_to_stream(gpu_file->get_file(), data, size);
   if (ret < 0)
     return {0, -ret};
   return ret;
 }
 
+int read_from_stdin(void *buf, size_t size) {
+  int ret = 0;
+  uint64_t recv_size;
+  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STDIN>();
+  port.send([=](rpc::Buffer *buffer) { buffer->data[0] = size; });
+  port.recv_n(&buf, &recv_size, [&](uint64_t) { return buf; });
+  port.recv([&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
+  port.close();
+  return ret;
+}
+
+int read_from_stream(uintptr_t file, void *buf, size_t size) {
+  int ret = 0;
+  uint64_t recv_size;
+  // TODO: For large sizes being written to a pointer in global memory, we
+  // should be able to initiate a H2D memcpy via a separate RPC call at high
+  // bandwidth.
+  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STREAM>();
+  port.send([=](rpc::Buffer *buffer) {
+    buffer->data[0] = size;
+    buffer->data[1] = file;
+  });
+  port.recv_n(&buf, &recv_size, [&](uint64_t) { return buf; });
+  port.recv([&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
+  port.close();
+  return ret;
+}
+
+FileIOResult read_func(File *f, void *buf, size_t size) {
+  auto *gpu_file = reinterpret_cast<GPUFile *>(f);
+  int ret = 0;
+  if (gpu_file == stdin)
+    ret = read_from_stdin(buf, size);
+  else
+    ret = read_from_stream(gpu_file->get_file(), buf, size);
+  if (ret < 0)
+    return {0, -ret};
+  return ret;
+}
+
 int close_func(File *file) {
   int ret = 0;
   GPUFile *gpu_file = reinterpret_cast<GPUFile *>(file);
   rpc::Client::Port port = rpc::client.open<RPC_CLOSE_FILE>();
   port.send_and_recv(
       [=](rpc::Buffer *buffer) { buffer->data[0] = gpu_file->get_file(); },
       [&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
   port.close();

libc/test/src/stdio/CMakeLists.txt

 
 add_libc_test(
   fopen_test
   SUITE
     libc_stdio_unittests
   SRCS
     fopen_test.cpp
   DEPENDS
+    libc.src.stdio.fread
     libc.src.stdio.fputs
     libc.src.stdio.fclose
     libc.src.stdio.fopen
 )
 
 add_libc_unittest(
   putc_test
   SUITE

libc/test/src/stdio/fopen_test.cpp

 //===-- Unittests for fopen / fclose --------------------------------------===//
 //
 // 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/File/file.h"
 #include "src/stdio/fclose.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fputs.h"
+#include "src/stdio/fread.h"
 
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcFOpenTest, PrintToFile) {
   int result;
 
   FILE *file = __llvm_libc::fopen("./testdata/test_data.txt", "w");
   ASSERT_FALSE(file == nullptr);
 
-  constexpr char another[] = "A simple string written to a file\n";
-  result = __llvm_libc::fputs(another, file);
+  constexpr char string[] = "A simple string written to a file\n";
+  result = __llvm_libc::fputs(string, file);
   EXPECT_GE(result, 0);
 
   ASSERT_EQ(0, __llvm_libc::fclose(file));
+
+  FILE *new_file = __llvm_libc::fopen("./testdata/test_data.txt", "r");
+  ASSERT_FALSE(new_file == nullptr);
+
+  static char data[64] = {0};
+  ASSERT_EQ(__llvm_libc::fread(data, 1, sizeof(string) - 1, file),
+            sizeof(string) - 1);
+  data[sizeof(string) - 1] = '\0';
+  ASSERT_STREQ(data, string);
+
+  ASSERT_EQ(0, __llvm_libc::fclose(new_file));
 }

libc/utils/gpu/server/rpc_server.cpp

case RPC_WRITE_TO_STDOUT: {
         std::memcpy(buffer->data, &ret, sizeof(int));
       });
       for (uint64_t i = 0; i < rpc::MAX_LANE_SIZE; ++i) {
         if (strs[i])
           delete[] reinterpret_cast<uint8_t *>(strs[i]);
       }
       break;
     }
+    case RPC_READ_FROM_STREAM:
+    case RPC_READ_FROM_STDIN: {
+      uint64_t sizes[rpc::MAX_LANE_SIZE] = {0};
+      void *data[rpc::MAX_LANE_SIZE] = {nullptr};
+      uint64_t rets[rpc::MAX_LANE_SIZE] = {0};
+      port->recv([&](rpc::Buffer *buffer, uint32_t id) {
+        sizes[id] = buffer->data[0];
+        data[id] = new char[sizes[id]];
+        FILE *file = port->get_opcode() == RPC_READ_FROM_STREAM
+                         ? reinterpret_cast<FILE *>(buffer->data[1])
+                         : stdin;
+        rets[id] = fread(data[id], sizes[id], 1, file);
+      });
+      port->send_n(data, sizes);
+      port->send([&](rpc::Buffer *buffer, uint32_t id) {
+        delete[] reinterpret_cast<uint8_t *>(data[id]);
+        buffer->data[0] = rets[id] >= 0 ? sizes[id] : rets[id];
+      });
+      break;
+    }
     case RPC_OPEN_FILE: {
       uint64_t sizes[rpc::MAX_LANE_SIZE] = {0};
       void *paths[rpc::MAX_LANE_SIZE] = {nullptr};
       port->recv_n(paths, sizes, [&](uint64_t size) { return new char[size]; });
       port->recv_and_send([&](rpc::Buffer *buffer, uint32_t id) {
         FILE *file = fopen(reinterpret_cast<char *>(paths[id]),
                            reinterpret_cast<char *>(buffer->data));
         buffer->data[0] = reinterpret_cast<uintptr_t>(file);