optimize file operation and http coroutine client (#5829)

Author: NathanFreeman

.github/workflows/core.yml

@@ -47,7 +47,7 @@ jobs:
 
       - name: build
         run: |
-          cmake . -D CODE_COVERAGE=ON -D enable_thread=1 -D verbose=1 || exit 1
+          cmake . -D CODE_COVERAGE=ON -D enable_thread=1 -D verbose=1 -D async_io=1 || exit 1
           make VERBOSE=1 -j $(nproc) core-tests || exit 1
 
       - name: run tests

CMakeLists.txt

@@ -127,6 +127,12 @@ if (DEFINED enable_thread)
     add_definitions(-DSW_THREAD)
 endif()
 
+if (DEFINED async_io)
+    # This macro is exclusively used for kernel unit testing to
+    # verify the asynchronous operation functionality of the file thread pool.
+    add_definitions(-DSW_USE_ASYNC)
+endif()
+
 if (DEFINED verbose)
     add_definitions(-DSW_VERBOSE)
 endif()

core-tests/src/coroutine/file.cpp

@@ -0,0 +1,54 @@
+/*
+ +----------------------------------------------------------------------+
+ | Swoole                                                               |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.0 of the Apache license,    |
+ | that is bundled with this package in the file LICENSE, and is        |
+ | available through the world-wide-web at the following url:           |
+ | http://www.apache.org/licenses/LICENSE-2.0.html                      |
+ | If you did not receive a copy of the Apache2.0 license and are unable|
+ | to obtain it through the world-wide-web, please send a note to       |
+ | [email protected] so we can mail you a copy immediately.            |
+ +----------------------------------------------------------------------+
+ | Author: NathanFreeman  <[email protected]>                         |
+ +----------------------------------------------------------------------+
+*/
+
+#include <sys/file.h>
+#include <sys/stat.h>
+#include "test_coroutine.h"
+#include "swoole_file.h"
+
+using namespace std;
+using namespace swoole;
+using swoole::coroutine::System;
+
+TEST(coroutine_async_file, async_file) {
+    coroutine::run([](void *arg) {
+        string filename = "/tmp/file.txt";
+        auto file = new AsyncFile(filename, O_CREAT | O_RDWR, 0666);
+        ON_SCOPE_EXIT {
+            delete file;
+        };
+        ASSERT_EQ(file->ready(), true);
+        ASSERT_EQ(file->truncate(0), true);
+        ASSERT_EQ(file->set_offset(0), 0);
+        ASSERT_EQ(file->get_offset(), 0);
+
+        const char *data = "Hello World!";
+        size_t length = strlen(data);
+        ASSERT_EQ(file->write((void *) data, length), static_cast<ssize_t>(length));
+
+        ASSERT_EQ(file->sync(), true);
+        ASSERT_EQ(file->set_offset(0), 0);
+
+        char buf[1024];
+        ASSERT_EQ(file->read((void *) buf, 1024), static_cast<ssize_t>(length));
+        buf[length] = '\0';
+        ASSERT_STREQ(data, buf);
+
+        struct stat statbuf {};
+        ASSERT_EQ(file->stat(&statbuf), true);
+        ASSERT_TRUE(statbuf.st_size > 0);
+    });
+}

core-tests/src/coroutine/hook.cpp

@@ -45,13 +45,13 @@ void static test_file_hook() {
     ASSERT_EQ(swoole_coroutine_fsync(fd), 0);
     ASSERT_EQ(swoole_coroutine_fdatasync(fd), 0);
 
-    swoole_coroutine_close_file(fd);
+    swoole_coroutine_close(fd);
 
     fd = swoole_coroutine_open(test_file, O_RDONLY, 0);
     char data[8192];
     ASSERT_EQ(swoole_coroutine_read(fd, data, n_buf), n_buf);
     ASSERT_EQ(std::string(buf, n_buf), std::string(data, n_buf));
-    swoole_coroutine_close_file(fd);
+    swoole_coroutine_close(fd);
 
     struct stat statbuf;
     swoole_coroutine_stat(test_file, &statbuf);
@@ -735,3 +735,17 @@ TEST(coroutine_hook, freopen) {
     coroutine::run([&](void *arg) { test_freopen(); });
     test_freopen();
 }
+
+TEST(coroutine_hook, ftruncate) {
+    coroutine::run([&](void *arg) {
+        int fd = swoole_coroutine_open("/tmp/123.txt", O_CREAT | O_RDWR, 0);
+        ASSERT_TRUE(fd > 0);
+
+        const char *data = "aaaaaaaaaaaaaaaaaaaaaaa";
+        size_t length = strlen(data);
+        ssize_t write_length = swoole_coroutine_write(fd, (const void *) data, length);
+        ASSERT_TRUE(write_length == static_cast<ssize_t>(length));
+        ASSERT_TRUE(swoole_coroutine_ftruncate(fd, 0) == 0);
+        swoole_coroutine_close(fd);
+    });
+}

core-tests/src/coroutine/iouring.cpp

@@ -46,53 +46,53 @@ TEST(iouring, list_all_opcode) {
 TEST(iouring, open_and_close) {
     coroutine::run([](void *arg) {
         const char *test_file = "/tmp/file_1";
-        int fd = swoole_coroutine_iouring_open(test_file, O_CREAT, 0666);
+        int fd = Iouring::open(test_file, O_CREAT, 0666);
         ASSERT_TRUE(fd > 0);
 
-        int result = swoole_coroutine_iouring_close_file(fd);
+        int result = Iouring::close(fd);
         ASSERT_TRUE(result == 0);
 
-        result = swoole_coroutine_iouring_unlink(test_file);
+        result = Iouring::unlink(test_file);
         ASSERT_TRUE(result == 0);
     });
 }
 
 TEST(iouring, mkdir_and_rmdir) {
     coroutine::run([](void *arg) {
         const char *directory = "/tmp/aaaa";
-        int result = swoole_coroutine_iouring_mkdir(directory, 0755);
+        int result = Iouring::mkdir(directory, 0755);
         ASSERT_TRUE(result == 0);
 
-        result = swoole_coroutine_iouring_rmdir(directory);
+        result = Iouring::rmdir(directory);
         ASSERT_TRUE(result == 0);
     });
 }
 
 TEST(iouring, write_and_read) {
     coroutine::run([](void *arg) {
         const char *test_file = "/tmp/file_2";
-        int fd = swoole_coroutine_iouring_open(test_file, O_CREAT | O_RDWR, 0666);
+        int fd = Iouring::open(test_file, O_CREAT | O_RDWR, 0666);
         ASSERT_TRUE(fd > 0);
 
         const char *data = "aaaaaaaaaaaaaaaaaaaaaaa";
         size_t length = strlen(data);
-        ssize_t result = swoole_coroutine_iouring_write(fd, (const void *) data, length);
+        ssize_t result = Iouring::write(fd, (const void *) data, length);
         ASSERT_TRUE(result > 0);
         ASSERT_TRUE(result == static_cast<ssize_t>(length));
 
         lseek(fd, 0, SEEK_SET);
 
         char buf[128];
-        result = swoole_coroutine_iouring_read(fd, (void *) buf, 128);
+        result = Iouring::read(fd, (void *) buf, 128);
         ASSERT_TRUE(result > 0);
         ASSERT_TRUE(result == static_cast<ssize_t>(length));
         buf[result] = '\0';
         ASSERT_STREQ(data, buf);
 
-        result = swoole_coroutine_iouring_close_file(fd);
+        result = Iouring::close(fd);
         ASSERT_TRUE(result == 0);
 
-        result = swoole_coroutine_iouring_unlink(test_file);
+        result = Iouring::unlink(test_file);
         ASSERT_TRUE(result == 0);
     });
 }
@@ -101,64 +101,85 @@ TEST(iouring, rename) {
     coroutine::run([](void *arg) {
         const char *oldpath = "/tmp/file_2";
         const char *newpath = "/tmp/file_3";
-        int fd = swoole_coroutine_iouring_open(oldpath, O_CREAT | O_RDWR, 0666);
+        int fd = Iouring::open(oldpath, O_CREAT | O_RDWR, 0666);
         ASSERT_TRUE(fd > 0);
 
-        int result = swoole_coroutine_iouring_close_file(fd);
+        int result = Iouring::close(fd);
         ASSERT_TRUE(result == 0);
 
-        result = swoole_coroutine_iouring_rename(oldpath, newpath);
+        result = Iouring::rename(oldpath, newpath);
         ASSERT_TRUE(result == 0);
 
-        result = swoole_coroutine_iouring_unlink(newpath);
+        result = Iouring::unlink(newpath);
         ASSERT_TRUE(result == 0);
     });
 }
 
+#ifdef HAVE_IOURING_STATX
 TEST(iouring, fstat_and_stat) {
     coroutine::run([](void *arg) {
         struct stat statbuf {};
-        int fd = swoole_coroutine_iouring_open(TEST_TMP_FILE, O_RDWR, 0666);
+        int fd = Iouring::open(TEST_TMP_FILE, O_RDWR, 0666);
         ASSERT_TRUE(fd > 0);
-        int result = swoole_coroutine_iouring_fstat(fd, &statbuf);
+        int result = Iouring::fstat(fd, &statbuf);
         ASSERT_TRUE(result == 0);
         ASSERT_TRUE(statbuf.st_size > 0);
 
-        result = swoole_coroutine_iouring_close_file(fd);
+        result = Iouring::close(fd);
         ASSERT_TRUE(result == 0);
 
         statbuf = {};
-        result = swoole_coroutine_iouring_stat(TEST_TMP_FILE, &statbuf);
+        result = Iouring::stat(TEST_TMP_FILE, &statbuf);
         ASSERT_TRUE(result == 0);
         ASSERT_TRUE(statbuf.st_size > 0);
     });
 }
+#endif
 
 TEST(iouring, fsync_and_fdatasync) {
     coroutine::run([](void *arg) {
         const char *test_file = "/tmp/file_2";
-        int fd = swoole_coroutine_iouring_open(test_file, O_CREAT | O_RDWR, 0666);
+        int fd = Iouring::open(test_file, O_CREAT | O_RDWR, 0666);
         ASSERT_TRUE(fd > 0);
 
         const char *data = "aaaaaaaaaaaaaaaaaaaaaaa";
         size_t length = strlen(data);
-        ssize_t write_length = swoole_coroutine_iouring_write(fd, (const void *) data, length);
+        ssize_t write_length = Iouring::write(fd, (const void *) data, length);
         ASSERT_TRUE(write_length == static_cast<ssize_t>(length));
 
-        int result = swoole_coroutine_iouring_fsync(fd);
+        int result = Iouring::fsync(fd);
         ASSERT_TRUE(result == 0);
 
-        write_length = swoole_coroutine_iouring_write(fd, (const void *) data, length);
+        write_length = Iouring::write(fd, (const void *) data, length);
         ASSERT_TRUE(write_length == static_cast<ssize_t>(length));
 
-        result = swoole_coroutine_iouring_fdatasync(fd);
+        result = Iouring::fdatasync(fd);
+        ASSERT_TRUE(result == 0);
+
+        result = Iouring::close(fd);
         ASSERT_TRUE(result == 0);
 
-        result = swoole_coroutine_iouring_close_file(fd);
+        result = Iouring::unlink(test_file);
         ASSERT_TRUE(result == 0);
+    });
+}
+
+#ifdef HAVE_IOURING_FTRUNCATE
+TEST(iouring, ftruncate) {
+    coroutine::run([&](void *arg) {
+        const char *test_file = "/tmp/file_3";
+        int fd = Iouring::open(test_file, O_CREAT | O_RDWR, 0666);
+        ASSERT_TRUE(fd > 0);
+
+        const char *data = "aaaaaaaaaaaaaaaaaaaaaaa";
+        size_t length = strlen(data);
+        ssize_t write_length = Iouring::write(fd, (const void *) data, length);
+        ASSERT_TRUE(write_length == static_cast<ssize_t>(length));
 
-        result = swoole_coroutine_iouring_unlink(test_file);
+        int result = Iouring::ftruncate(fd, 0);
         ASSERT_TRUE(result == 0);
+        Iouring::close(fd);
     });
 }
 #endif
+#endif

ext-src/swoole_http_client_coro.cc

@@ -36,7 +36,7 @@ SW_EXTERN_C_BEGIN
 #include "ext/standard/base64.h"
 
 SW_EXTERN_C_END
-using swoole::File;
+using swoole::AsyncFile;
 using swoole::String;
 using swoole::coroutine::Socket;
 using swoole::network::Address;
@@ -126,8 +126,8 @@ class Client {
     bool in_callback = false;
     bool has_upload_files = false;
 
-    std::shared_ptr<File> download_file;  // save http response to file
-    zend::String download_file_name;      // unlink the file on error
+    std::shared_ptr<AsyncFile> download_file;  // save http response to file
+    zend::String download_file_name;           // unlink the file on error
     zend_long download_offset = 0;
 
     /* safety zval */
@@ -486,14 +486,6 @@ static int http_parser_on_headers_complete(llhttp_t *parser) {
     return 0;
 }
 
-static inline ssize_t http_client_co_write(int sockfd, const void *buf, size_t count) {
-#ifdef SW_USE_IOURING
-    return swoole_coroutine_iouring_write(sockfd, buf, count);
-#else
-    return swoole_coroutine_write(sockfd, buf, count);
-#endif
-}
-
 static int http_parser_on_body(llhttp_t *parser, const char *at, size_t length) {
     auto *http = static_cast<Client *>(parser->data);
     if (http->write_func) {
@@ -525,7 +517,7 @@ static int http_parser_on_body(llhttp_t *parser, const char *at, size_t length)
     if (http->download_file_name.get() && http->body->length > 0) {
         if (http->download_file == nullptr) {
             char *download_file_name = http->download_file_name.val();
-            std::shared_ptr<File> fp = std::make_shared<File>(download_file_name, O_CREAT | O_WRONLY, 0664);
+            auto fp = std::make_shared<AsyncFile>(download_file_name, O_CREAT | O_WRONLY, 0664);
             if (!fp->ready()) {
                 swoole_sys_warning("open(%s, O_CREAT | O_WRONLY) failed", download_file_name);
                 return -1;
@@ -543,8 +535,7 @@ static int http_parser_on_body(llhttp_t *parser, const char *at, size_t length)
             }
             http->download_file = fp;
         }
-        if (http_client_co_write(http->download_file->get_fd(), SW_STRINGL(http->body)) !=
-            (ssize_t) http->body->length) {
+        if (http->download_file->write(SW_STRINGL(http->body)) != (ssize_t) http->body->length) {
             return -1;
         }
         http->body->clear();

ext-src/swoole_runtime.cc

@@ -238,6 +238,7 @@ static zend::ConcurrencyHashMap<std::string, zend_internal_arg_info *> ori_func_
 SW_EXTERN_C_BEGIN
 #include "ext/standard/file.h"
 #include "thirdparty/php/streams/plain_wrapper.c"
+#undef close
 SW_EXTERN_C_END
 
 void php_swoole_runtime_minit(int module_number) {