Optimize AsyncEvent

include/swoole_async.h

@@ -35,18 +35,12 @@ enum AsyncFlag {
 };
 
 struct AsyncEvent {
-    int fd;
     size_t task_id;
-    uint8_t lock;
     uint8_t canceled;
     /**
      * input & output
      */
-    uint16_t flags;
-    off_t offset;
-    size_t nbytes;
-    void *buf;
-    void *req;
+    void *data;
     /**
      * output
      */
@@ -66,6 +60,13 @@ struct AsyncEvent {
     }
 };
 
+struct GethostbynameData {
+    const char *hostname;
+    int domain;
+    char *host;
+    size_t host_len;
+};
+
 class AsyncThreads {
   public:
     bool schedule = false;

src/coroutine/system.cc

@@ -137,21 +137,22 @@ ssize_t System::write_file(const char *file, char *buf, size_t length, bool lock
 
 std::string gethostbyname_impl_with_async(const std::string &hostname, int domain, double timeout) {
     AsyncEvent ev{};
+    GethostbynameData data;
+    ev.data = &data;
 
     if (hostname.size() < INET6_ADDRSTRLEN) {
-        ev.nbytes = INET6_ADDRSTRLEN + 1;
+        data.host_len = INET6_ADDRSTRLEN + 1;
     } else {
-        ev.nbytes = hostname.size() + 1;
+        data.host_len = hostname.size() + 1;
     }
 
-    ev.buf = sw_malloc(ev.nbytes);
-    if (!ev.buf) {
+    data.host = (char *) sw_malloc(data.host_len);
+    if (!data.host) {
         return "";
     }
 
-    memcpy(ev.buf, hostname.c_str(), hostname.size());
-    ((char *) ev.buf)[hostname.size()] = 0;
-    ev.flags = domain;
+    data.hostname = hostname.c_str();
+    data.domain = domain;
     ev.retval = 1;
 
     coroutine::async(async::handler_gethostbyname, ev, timeout);
@@ -163,8 +164,8 @@ std::string gethostbyname_impl_with_async(const std::string &hostname, int domai
         swoole_set_last_error(ev.error);
         return "";
     } else {
-        std::string addr((char *) ev.buf);
-        sw_free(ev.buf);
+        std::string addr(data.host);
+        sw_free(data.host);
         return addr;
     }
 }
@@ -215,7 +216,7 @@ std::vector<std::string> System::getaddrinfo(
     AsyncEvent ev{};
     network::GetaddrinfoRequest req{};
 
-    ev.req = &req;
+    ev.data = &req;
 
     struct sockaddr_in6 result_buffer[SW_DNS_HOST_BUFFER_SIZE];
 
@@ -639,7 +640,7 @@ bool async(async::Handler handler, AsyncEvent &event, double timeout) {
         return false;
     } else {
         event.canceled = _ev->canceled;
-        event.error =  errno = _ev->error;
+        event.error = errno = _ev->error;
         event.retval = _ev->retval;
         return true;
     }

src/network/client.cc

@@ -615,30 +615,31 @@ static int Client_tcp_connect_async(Client *cli, const char *host, int port, dou
 
     if (cli->wait_dns) {
         AsyncEvent ev{};
+        auto data = (GethostbynameData *) sw_malloc(sizeof(GethostbynameData));
+        ev.data = data;
 
         size_t len = strlen(cli->server_host);
         if (len < INET6_ADDRSTRLEN) {
-            ev.nbytes = INET6_ADDRSTRLEN;
+            data->host_len = INET6_ADDRSTRLEN;
         } else {
-            ev.nbytes = len + 1;
+            data->host_len = len + 1;
         }
 
-        ev.buf = sw_malloc(ev.nbytes);
-        if (!ev.buf) {
+        data->host = (char *) sw_malloc(data->host_len);
+        if (!data->host) {
             swoole_warning("malloc failed");
             return SW_ERR;
         }
 
-        memcpy(ev.buf, cli->server_host, len);
-        ((char *) ev.buf)[len] = 0;
-        ev.flags = cli->_sock_domain;
+        data->hostname = host;
+        data->domain = cli->_sock_domain;
         ev.object = cli;
-        ev.fd = cli->socket->fd;
         ev.handler = async::handler_gethostbyname;
         ev.callback = Client_onResolveCompleted;
 
         if (swoole::async::dispatch(&ev) == nullptr) {
-            sw_free(ev.buf);
+            sw_free(data->host);
+            sw_free(data);
             return SW_ERR;
         } else {
             return SW_OK;
@@ -1128,16 +1129,18 @@ static void Client_onTimeout(Timer *timer, TimerNode *tnode) {
 }
 
 static void Client_onResolveCompleted(AsyncEvent *event) {
+    auto data = (GethostbynameData *) event->data;
     if (event->canceled) {
-        sw_free(event->buf);
+        sw_free(data->host);
+        sw_free(data);
         return;
     }
 
     Client *cli = (Client *) event->object;
     cli->wait_dns = 0;
 
     if (event->error == 0) {
-        Client_tcp_connect_async(cli, (char *) event->buf, cli->server_port, cli->timeout, 1);
+        Client_tcp_connect_async(cli, data->host, cli->server_port, cli->timeout, 1);
     } else {
         swoole_set_last_error(SW_ERROR_DNSLOOKUP_RESOLVE_FAILED);
         cli->socket->removed = 1;
@@ -1146,7 +1149,8 @@ static void Client_onResolveCompleted(AsyncEvent *event) {
             cli->onError(cli);
         }
     }
-    sw_free(event->buf);
+    sw_free(data->host);
+    sw_free(data);
 }
 
 static int Client_onWrite(Reactor *reactor, Event *event) {

src/os/base.cc

@@ -85,13 +85,14 @@ namespace async {
 
 void handler_gethostbyname(AsyncEvent *event) {
     char addr[INET6_ADDRSTRLEN];
-    int ret = network::gethostbyname(event->flags, (char *) event->buf, addr);
-    sw_memset_zero(event->buf, event->nbytes);
+    auto data = (GethostbynameData *) event->data;
+    int ret = network::gethostbyname(data->domain, data->hostname, addr);
+    sw_memset_zero(data->host, data->host_len);
 
     if (ret < 0) {
         event->error = SW_ERROR_DNSLOOKUP_RESOLVE_FAILED;
     } else {
-        if (inet_ntop(event->flags, addr, (char *) event->buf, event->nbytes) == nullptr) {
+        if (inet_ntop(data->domain, addr, data->host, data->host_len) == nullptr) {
             ret = -1;
             event->error = SW_ERROR_BAD_IPV6_ADDRESS;
         } else {
@@ -103,7 +104,7 @@ void handler_gethostbyname(AsyncEvent *event) {
 }
 
 void handler_getaddrinfo(AsyncEvent *event) {
-    network::GetaddrinfoRequest *req = (network::GetaddrinfoRequest *) event->req;
+    network::GetaddrinfoRequest *req = (network::GetaddrinfoRequest *) event->data;
     event->retval = network::getaddrinfo(req);
     event->error = req->error;
 }