Optimize send to worker from master (#3910)

* Optimize the process of sending data from master to worker

* Fix

* Update

* Fix

* Optimize test

* Fix reactor buffer append

* optimeize code

* fix tests

* fix tests [2]

* optimize code

* fix tests

* fix tests[4]

* fix tests[5]

* fix tests[6]

* add const

* fix tests

* fix tests [7]

Co-authored-by: codinghuang <[email protected]>

Author: matyhtf

core-tests/src/memory/buffer.cpp

@@ -0,0 +1,71 @@
+/*
+  +----------------------------------------------------------------------+
+  | 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.            |
+  +----------------------------------------------------------------------+
+  | @link     https://www.swoole.com/                                    |
+  | @contact  [email protected]                                            |
+  | @license  https://github.com/swoole/swoole-src/blob/master/LICENSE   |
+  | @author   Tianfeng Han  <[email protected]>                      |
+  +----------------------------------------------------------------------+
+*/
+
+#include "test_core.h"
+#include "swoole_memory.h"
+#include "swoole_buffer.h"
+
+using namespace std;
+using namespace swoole;
+
+TEST(buffer, append_iov) {
+    Buffer buf(1024);
+
+    int iovcnt = 4;
+    iovec v[iovcnt];
+
+    v[0].iov_len = swoole_rand(99, 4095);
+    v[1].iov_len = swoole_rand(99, 4095);
+    v[2].iov_len = swoole_rand(99, 4095);
+    v[3].iov_len = swoole_rand(99, 4095);
+
+    unique_ptr<char> s1(new char[v[0].iov_len]);
+    unique_ptr<char> s2(new char[v[1].iov_len]);
+    unique_ptr<char> s3(new char[v[2].iov_len]);
+    unique_ptr<char> s4(new char[v[3].iov_len]);
+
+    v[0].iov_base = s1.get();
+    v[1].iov_base = s2.get();
+    v[2].iov_base = s3.get();
+    v[3].iov_base = s4.get();
+
+    memset(v[0].iov_base, 'A', v[0].iov_len);
+    memset(v[1].iov_base, 'B', v[1].iov_len);
+    memset(v[2].iov_base, 'C', v[2].iov_len);
+    memset(v[3].iov_base, 'D', v[3].iov_len);
+
+    buf.append(v, iovcnt, 0);
+
+    ASSERT_EQ(buf.length(), v[0].iov_len + v[1].iov_len + v[2].iov_len+ v[3].iov_len);
+
+    String str(buf.length());
+    
+    while(!buf.empty()) {
+        auto chunk = buf.front();
+        str.append(chunk->value.ptr, chunk->length);
+        buf.pop();
+    }
+
+    size_t offset = 0;
+
+    SW_LOOP_N (iovcnt) {
+        ASSERT_EQ(memcmp(str.str + offset, v[i].iov_base, v[i].iov_len), 0);
+        offset += v[i].iov_len;
+    }
+}

ext-src/swoole_http2_client_coro.cc

@@ -919,7 +919,7 @@ int Client::parse_header(Stream *stream, int flags, char *in, size_t inlen) {
         inlen -= (size_t) rv;
 
         swTraceLog(SW_TRACE_HTTP2,
-                   "[" SW_ECHO_GREEN "] %.*s[%d]: %.*s[%d]",
+                   "[" SW_ECHO_GREEN "] %.*s[%lu]: %.*s[%lu]",
                    "HEADER",
                    (int) nv.namelen,
                    nv.name,
@@ -1297,7 +1297,7 @@ bool Client::send_goaway_frame(zend_long error_code, const char *debug_data, siz
         memcpy(frame + SW_HTTP2_FRAME_HEADER_SIZE + SW_HTTP2_GOAWAY_SIZE, debug_data, debug_data_len);
     }
     swTraceLog(SW_TRACE_HTTP2,
-               "[" SW_ECHO_GREEN "] Send: last-sid=%d, error-code=%d",
+               "[" SW_ECHO_GREEN "] Send: last-sid=%u, error-code=%ld",
                swHttp2_get_type(SW_HTTP2_TYPE_GOAWAY),
                last_stream_id,
                error_code);

ext-src/swoole_http_server.cc

@@ -70,7 +70,7 @@ int php_swoole_http_onReceive(Server *serv, RecvData *req) {
     php_swoole_get_recv_data(serv, zdata, req);
 
     swTraceLog(SW_TRACE_SERVER,
-               "http request from %d with %d bytes: <<EOF\n%.*s\nEOF",
+               "http request from %ld with %d bytes: <<EOF\n%.*s\nEOF",
                session_id,
                (int) Z_STRLEN_P(zdata),
                (int) Z_STRLEN_P(zdata),

include/swoole_api.h

@@ -43,6 +43,7 @@ SW_API int swoole_event_set(swoole::network::Socket *socket, int events);
 SW_API int swoole_event_del(swoole::network::Socket *socket);
 SW_API void swoole_event_defer(swoole::Callback cb, void *private_data);
 SW_API ssize_t swoole_event_write(swoole::network::Socket *socket, const void *data, size_t len);
+SW_API ssize_t swoole_event_writev(swoole::network::Socket *socket, const iovec *iov, size_t iovcnt);
 SW_API int swoole_event_wait();
 SW_API int swoole_event_free();
 SW_API bool swoole_event_set_handler(int fdtype, swoole::ReactorHandler handler);

include/swoole_buffer.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <queue>
+#include <sys/uio.h>
 
 namespace swoole {
 
@@ -61,6 +62,7 @@ class Buffer {
 
     void pop();
     void append(const void *data, uint32_t size);
+    void append(const struct iovec *iov, size_t iovcnt, off_t offset);
 
     uint32_t length() {
         return total_length;
@@ -70,6 +72,10 @@ class Buffer {
         return queue_.size();
     }
 
+    bool empty() {
+        return queue_.empty();
+    }
+
     static bool empty(Buffer *buffer) {
         return buffer == nullptr || buffer->queue_.empty();
     }

include/swoole_reactor.h

@@ -167,6 +167,7 @@ class Reactor {
     std::function<void(Reactor *)> onBegin;
 
     int (*write)(Reactor *reactor, network::Socket *socket, const void *buf, size_t n) = nullptr;
+    int (*writev)(Reactor *reactor, network::Socket *socket, const iovec *iov, size_t iovcnt) = nullptr;
     int (*close)(Reactor *reactor, network::Socket *socket) = nullptr;
 
   private:
@@ -324,6 +325,7 @@ class Reactor {
     }
 
     static int _write(Reactor *reactor, network::Socket *socket, const void *buf, size_t n);
+    static int _writev(Reactor *reactor, network::Socket *socket, const iovec *iov, size_t iovcnt);
     static int _close(Reactor *reactor, network::Socket *socket);
     static int _writable_callback(Reactor *reactor, Event *ev);
 

include/swoole_server.h

@@ -1180,9 +1180,10 @@ class Server {
     static int dispatch_task(Protocol *proto, network::Socket *_socket, const char *data, uint32_t length);
 
     int send_to_connection(SendData *);
-    ssize_t send_to_worker_from_master(Worker *worker, const void *data, size_t len);
+    ssize_t send_to_worker_from_master(Worker *worker, const iovec *iov, size_t iovcnt);
     ssize_t send_to_worker_from_worker(Worker *dst_worker, const void *buf, size_t len, int flags);
-    ssize_t send_to_reactor_thread(EventData *ev_data, size_t sendn, SessionId session_id);
+    ssize_t send_to_reactor_thread(const EventData *ev_data, size_t sendn, SessionId session_id);
+    ssize_t send_to_reactor_thread(const DataHead *head, const iovec *iov, size_t iovcnt, SessionId session_id);
     int reply_task_result(const char *data, size_t data_len, int flags, EventData *current_task);
 
     bool send(SessionId session_id, const void *data, uint32_t length);

include/swoole_socket.h

@@ -117,6 +117,7 @@ struct IOVector {
     ~IOVector();
 
     void update_iterator(ssize_t __n);
+
     inline struct iovec *get_iterator() {
         return iov_iterator;
     }
@@ -306,6 +307,10 @@ struct Socket {
     ssize_t readv(IOVector *io_vector);
     ssize_t writev(IOVector *io_vector);
 
+    ssize_t writev(const struct iovec *iov, size_t iovcnt) {
+        return ::writev(fd, iov, iovcnt);
+    }
+
     int bind(const Address &sa) {
         return ::bind(fd, &sa.addr.ss, sizeof(sa.addr.ss));
     }
@@ -319,6 +324,7 @@ struct Socket {
     ssize_t send_async(const void *__data, size_t __len);
     ssize_t recv_blocking(void *__data, size_t __len, int flags);
     int sendfile_blocking(const char *filename, off_t offset, size_t length, double timeout);
+    ssize_t writev_blocking(const struct iovec *iov, size_t iovcnt);
 
     inline int connect(const Address &sa) {
         return ::connect(fd, &sa.addr.ss, sa.len);

include/swoole_string.h

@@ -159,6 +159,15 @@ class String {
         }
     }
 
+    String *substr(size_t offset, size_t len) {
+        if (offset + len > length) {
+            return nullptr;
+        }
+        auto _substr = new String(len);
+        _substr->append(str + offset, len);
+        return _substr;
+    }
+
     bool empty() {
         return str == nullptr || length == 0;
     }

include/swoole_version.h

@@ -22,9 +22,9 @@
 #define SWOOLE_MINOR_VERSION 6
 #define SWOOLE_RELEASE_VERSION 0
 #define SWOOLE_EXTRA_VERSION "alpha"
-#define SWOOLE_VERSION "4.5.6"
+#define SWOOLE_VERSION "4.6.0-alpha"
 #define SWOOLE_VERSION_ID 40600
-#define SWOOLE_API_VERSION_ID 0x202011b
+#define SWOOLE_API_VERSION_ID 0x202012a
 
 #define SWOOLE_BUG_REPORT                                                                                              \
     "A bug occurred in Swoole-v" SWOOLE_VERSION ", please report it.\n"                                                \

src/memory/buffer.cc

@@ -72,11 +72,69 @@ void Buffer::append(const void *data, uint32_t size) {
         memcpy(chunk->value.ptr, _pos, _n);
         chunk->length = _n;
 
-        swTraceLog(SW_TRACE_BUFFER, "chunk_n=%d|size=%d|chunk_len=%d|chunk=%p", count(), _n, chunk->length, chunk);
+        swTraceLog(SW_TRACE_BUFFER, "chunk_n=%lu|size=%u|chunk_len=%u|chunk=%p", count(), _n, chunk->length, chunk);
 
         _pos += _n;
         _length -= _n;
     }
 }
 
+void Buffer::append(const struct iovec *iov, size_t iovcnt, off_t offset) {
+    size_t _length = 0;
+
+    SW_LOOP_N(iovcnt) {
+        _length += iov[i].iov_len;
+    }
+
+    char *pos = (char *) iov[0].iov_base;
+    BufferChunk *chunk = nullptr;
+    size_t iov_remain_len = iov[0].iov_len, chunk_remain_len;
+    size_t i = 0;
+
+    while (true) {
+        if (chunk) {
+            if (chunk->size == chunk->length) {
+                chunk = nullptr;
+                continue;
+            } else {
+                chunk_remain_len = chunk->size - chunk->length;
+            }
+        } else {
+            if (offset > 0) {
+                if (offset >= (off_t) iov[i].iov_len) {
+                    offset -= iov[i].iov_len;
+                    i++;
+                    continue;
+                } else {
+                    offset = 0;
+                    pos += offset;
+                    iov_remain_len -= offset;
+                }
+            }
+            chunk_remain_len = _length >= chunk_size ? chunk_size : _length;
+            chunk = alloc(BufferChunk::TYPE_DATA, chunk_remain_len);
+        }
+
+        size_t _n = std::min(iov_remain_len, chunk_remain_len);
+        memcpy(chunk->value.ptr + chunk->length, pos, _n);
+        total_length += _n;
+        _length -= _n;
+
+        swTraceLog(SW_TRACE_BUFFER, "chunk_n=%lu|size=%lu|chunk_len=%u|chunk=%p", count(), _n, chunk->length, chunk);
+
+        chunk->length += _n;
+        iov_remain_len -= _n;
+
+        if (iov_remain_len == 0) {
+            i++;
+            if (i == iovcnt) {
+                break;
+            }
+            iov_remain_len = iov[i].iov_len;
+            pos = (char *) iov[i].iov_base;
+        } else {
+            pos += _n;
+        }
+    }
+}
 }  // namespace swoole

src/network/socket.cc

@@ -122,6 +122,26 @@ int Socket::sendfile_blocking(const char *filename, off_t offset, size_t length,
     return SW_OK;
 }
 
+ssize_t Socket::writev_blocking(const struct iovec *iov, size_t iovcnt) {
+    while (1) {
+        ssize_t n = writev(iov, iovcnt);
+        if (n < 0) {
+            if (errno == EINTR) {
+                continue;
+            } else if (catch_error(errno) == SW_WAIT &&
+                       wait_event((int) (send_timeout_ * 1000), SW_EVENT_WRITE) == SW_OK) {
+                continue;
+            } else {
+                swSysWarn("send %lu bytes failed", iov[1].iov_len);
+                return SW_ERR;
+            }
+        } else {
+            return n;
+        }
+    }
+    return -1;
+}
+
 /**
  * clear socket buffer.
  */
@@ -532,7 +552,7 @@ int Socket::handle_sendfile() {
         ret = ::swoole_sendfile(fd, task->file.get_fd(), &task->offset, sendn);
     }
 
-    swTrace("ret=%d|task->offset=%ld|sendn=%d|filesize=%ld", ret, (long) task->offset, sendn, task->length);
+    swTrace("ret=%d|task->offset=%ld|sendn=%lu|filesize=%lu", ret, (long) task->offset, sendn, task->length);
 
     if (ret <= 0) {
         switch (catch_error(errno)) {
@@ -751,6 +771,7 @@ ssize_t Socket::readv(IOVector *io_vector) {
 
     return retval;
 }
+
 ssize_t Socket::writev(IOVector *io_vector) {
     ssize_t retval;
 
@@ -1118,7 +1139,7 @@ int Socket::ssl_sendfile(const File &fp, off_t *_offset, size_t _size) {
         } else {
             *_offset += ret;
         }
-        swTraceLog(SW_TRACE_REACTOR, "fd=%d, readn=%d, n=%d, ret=%d", fd, readn, n, ret);
+        swTraceLog(SW_TRACE_REACTOR, "fd=%d, readn=%ld, n=%ld, ret=%ld", fd, readn, n, ret);
         return ret;
     } else {
         swSysWarn("pread() failed");