fix: format code and fix compile error on mac

Author: lishuo121

include/ylt/coro_io/coro_file.hpp

@@ -135,7 +135,7 @@ inline bool open_native_async_file(File &file, Executor &executor,
 
     if (use_direct_io) {
 #if defined(ASIO_WINDOWS)
-#else
+#elif defined(__linux__)
       asio_flags = static_cast<asio::file_base::flags>(
           static_cast<int>(asio_flags) | O_DIRECT);
 #endif
@@ -149,6 +149,18 @@ inline bool open_native_async_file(File &file, Executor &executor,
       file = std::make_shared<asio::random_access_file>(
           executor.get_asio_executor(), std::string(filepath), asio_flags);
     }
+    
+    // On macOS, use F_NOCACHE as an alternative to O_DIRECT
+    if (use_direct_io && file && file->is_open()) {
+#if defined(__APPLE__) || defined(__MACH__)
+      int fd = file->native_handle();
+      if (fd >= 0 && fcntl(fd, F_NOCACHE, 1) != 0) {
+        std::error_code ec;
+        file->close(ec);
+        return false;
+      }
+#endif
+    }
   } catch (std::exception &ex) {
     ELOG_INFO << "line " << __LINE__ << " coro_file open failed" << ex.what()
               << "\n";
@@ -533,7 +545,7 @@ class basic_random_coro_file {
 
     if (use_direct_io) {
 #if defined(ASIO_WINDOWS)
-#else
+#elif defined(__linux__)
       open_flags |= O_DIRECT;
 #endif
     }
@@ -547,6 +559,16 @@ class basic_random_coro_file {
       return false;
     }
 
+    // On macOS, use F_NOCACHE as an alternative to O_DIRECT
+    if (use_direct_io) {
+#if defined(__APPLE__) || defined(__MACH__)
+      if (fcntl(fd, F_NOCACHE, 1) != 0) {
+        ::close(fd);
+        return false;
+      }
+#endif
+    }
+
     prw_random_file_ = std::shared_ptr<int>(new int(fd), [](int *ptr) {
 #if defined(ASIO_WINDOWS)
       _close(*ptr);

src/coro_io/tests/test_corofile.cpp

@@ -17,6 +17,7 @@
 #if !defined(ASIO_WINDOWS)
 #include <fcntl.h>
 #include <unistd.h>
+
 #include <cstdlib>
 #include <cstring>
 #endif
@@ -934,107 +935,118 @@ TEST_CASE("large_file_write_with_pool_test") {
 #if !defined(ASIO_WINDOWS)
 constexpr size_t DIRECT_IO_ALIGNMENT = 512;
 
-inline void* aligned_alloc_direct_io(size_t size) {
-  void* ptr = nullptr;
+inline void *aligned_alloc_direct_io(size_t size) {
+  void *ptr = nullptr;
   if (posix_memalign(&ptr, DIRECT_IO_ALIGNMENT, size) != 0) {
     return nullptr;
   }
   return ptr;
 }
 
-inline void aligned_free_direct_io(void* ptr) {
-  free(ptr);
-}
+inline void aligned_free_direct_io(void *ptr) { free(ptr); }
 
 inline size_t align_offset_for_direct_io(size_t offset) {
   return (offset / DIRECT_IO_ALIGNMENT) * DIRECT_IO_ALIGNMENT;
 }
 
 inline size_t align_size_for_direct_io(size_t size) {
-  return ((size + DIRECT_IO_ALIGNMENT - 1) / DIRECT_IO_ALIGNMENT) * DIRECT_IO_ALIGNMENT;
+  return ((size + DIRECT_IO_ALIGNMENT - 1) / DIRECT_IO_ALIGNMENT) *
+         DIRECT_IO_ALIGNMENT;
 }
 
 template <coro_io::execution_type execute_type>
 void test_direct_io_read_write(std::string_view filename) {
   size_t file_size = 8 * KB;
   create_files({std::string(filename)}, file_size);
-  
+
   auto executor = coro_io::get_global_block_executor();
   coro_io::basic_random_coro_file<execute_type> file(executor);
-  
+
   bool opened = file.open(filename, std::ios::in | std::ios::out, true);
   if (!opened) {
     WARN("Direct I/O not supported on this filesystem, skipping test");
     return;
   }
-  
+
   CHECK(file.is_open());
-  
+
   size_t aligned_size = align_size_for_direct_io(block_size);
-  void* aligned_buf = aligned_alloc_direct_io(aligned_size);
+  void *aligned_buf = aligned_alloc_direct_io(aligned_size);
   REQUIRE(aligned_buf != nullptr);
-  
+
   struct BufferGuard {
-    void* ptr;
+    void *ptr;
     ~BufferGuard() {
       if (ptr) {
         aligned_free_direct_io(ptr);
       }
     }
   } guard{aligned_buf};
-  
-  char* buf = static_cast<char*>(aligned_buf);
-  
+
+  char *buf = static_cast<char *>(aligned_buf);
+
   size_t aligned_offset = align_offset_for_direct_io(0);
   size_t aligned_read_size = align_size_for_direct_io(block_size);
-  
-  auto [ec, bytes_read] = async_simple::coro::syncAwait(
+
+  std::error_code ec;
+  size_t bytes_read;
+  std::tie(ec, bytes_read) = async_simple::coro::syncAwait(
       file.async_read_at(aligned_offset, buf, aligned_read_size));
-  
+
   CHECK(!ec);
   CHECK(bytes_read == aligned_read_size);
   CHECK(!file.eof());
-  
+
   std::memset(buf, 'X', aligned_read_size);
-  
-  auto [write_ec, bytes_written] = async_simple::coro::syncAwait(
+
+  std::error_code write_ec;
+  size_t bytes_written;
+  std::tie(write_ec, bytes_written) = async_simple::coro::syncAwait(
       file.async_write_at(aligned_offset, std::string_view(buf, aligned_read_size)));
-  
+
   CHECK(!write_ec);
   CHECK(bytes_written == aligned_read_size);
-  
+
   std::memset(buf, 0, aligned_read_size);
-  auto [read_ec, read_bytes] = async_simple::coro::syncAwait(
+  std::error_code read_ec;
+  size_t read_bytes;
+  std::tie(read_ec, read_bytes) = async_simple::coro::syncAwait(
       file.async_read_at(aligned_offset, buf, aligned_read_size));
-  
+
   CHECK(!read_ec);
   CHECK(read_bytes == aligned_read_size);
-  
+
   for (size_t i = 0; i < aligned_read_size; ++i) {
     CHECK(buf[i] == 'X');
   }
-  
-  for (size_t offset = 0; offset < file_size - aligned_read_size; offset += aligned_read_size) {
+
+  for (size_t offset = 0; offset < file_size - aligned_read_size;
+       offset += aligned_read_size) {
     size_t aligned_off = align_offset_for_direct_io(offset);
-    
-    std::memset(buf, 'A' + (offset / aligned_read_size) % 26, aligned_read_size);
-    auto [w_ec, w_bytes] = async_simple::coro::syncAwait(
-        file.async_write_at(aligned_off, std::string_view(buf, aligned_read_size)));
+
+    std::memset(buf, 'A' + (offset / aligned_read_size) % 26,
+                aligned_read_size);
+    std::error_code w_ec;
+    size_t w_bytes;
+    std::tie(w_ec, w_bytes) = async_simple::coro::syncAwait(file.async_write_at(
+        aligned_off, std::string_view(buf, aligned_read_size)));
     CHECK(!w_ec);
     CHECK(w_bytes == aligned_read_size);
-    
+
     std::memset(buf, 0, aligned_read_size);
-    auto [r_ec, r_bytes] = async_simple::coro::syncAwait(
+    std::error_code r_ec;
+    size_t r_bytes;
+    std::tie(r_ec, r_bytes) = async_simple::coro::syncAwait(
         file.async_read_at(aligned_off, buf, aligned_read_size));
     CHECK(!r_ec);
     CHECK(r_bytes == aligned_read_size);
-    
+
     char expected = 'A' + (offset / aligned_read_size) % 26;
     for (size_t i = 0; i < aligned_read_size; ++i) {
       CHECK(buf[i] == expected);
     }
   }
-  
+
   file.close();
 }
 #endif
@@ -1062,19 +1074,19 @@ TEST_CASE("direct io alignment test") {
   CHECK(align_offset_for_direct_io(512) == 512);
   CHECK(align_offset_for_direct_io(1000) == 512);
   CHECK(align_offset_for_direct_io(1024) == 1024);
-  
+
   CHECK(align_size_for_direct_io(0) == 0);
   CHECK(align_size_for_direct_io(100) == 512);
   CHECK(align_size_for_direct_io(512) == 512);
   CHECK(align_size_for_direct_io(1000) == 1024);
   CHECK(align_size_for_direct_io(1024) == 1024);
-  
-  void* ptr1 = aligned_alloc_direct_io(1024);
+
+  void *ptr1 = aligned_alloc_direct_io(1024);
   REQUIRE(ptr1 != nullptr);
   CHECK(reinterpret_cast<uintptr_t>(ptr1) % DIRECT_IO_ALIGNMENT == 0);
   aligned_free_direct_io(ptr1);
-  
-  void* ptr2 = aligned_alloc_direct_io(4096);
+
+  void *ptr2 = aligned_alloc_direct_io(4096);
   REQUIRE(ptr2 != nullptr);
   CHECK(reinterpret_cast<uintptr_t>(ptr2) % DIRECT_IO_ALIGNMENT == 0);
   aligned_free_direct_io(ptr2);