Optimization func name

Author: matyhtf

include/server.h

@@ -985,11 +985,11 @@ void swWorker_free(swWorker *worker);
 void swWorker_onStart(swServer *serv);
 void swWorker_onStop(swServer *serv);
 int swWorker_loop(swServer *serv, int worker_pti);
+void swWorker_clean_pipe_buffer(swServer *serv);
 int swWorker_send2reactor(swServer *serv, swEventData *ev_data, size_t sendn, int fd);
 int swWorker_send2worker(swWorker *dst_worker, void *buf, int n, int flag);
 void swWorker_signal_handler(int signo);
 void swWorker_signal_init(void);
-void swWorker_clean(void);
 
 /**
  * reactor_id: The fd in which the reactor.

php_swoole.h

@@ -296,7 +296,11 @@ PHP_FUNCTION(swoole_strerror);
 PHP_FUNCTION(swoole_errno);
 PHP_FUNCTION(swoole_last_error);
 
-/** <Sort by dependency> **/
+
+/**
+ * MINIT <Sort by dependency>
+ * ==============================================================
+ */
 void swoole_event_init(int module_number);
 // base
 void swoole_atomic_init(int module_number);
@@ -335,10 +339,11 @@ void swoole_redis_server_init(int module_number);
  * RSHUTDOWN
  * ==============================================================
  */
-void swoole_async_coro_shutdown();
-void swoole_redis_server_shutdown();
-void swoole_coroutine_shutdown();
-void swoole_runtime_shutdown();
+void swoole_async_coro_rshutdown();
+void swoole_redis_server_rshutdown();
+void swoole_coroutine_rshutdown();
+void swoole_runtime_rshutdown();
+void swoole_server_rshutdown();
 
 void php_swoole_process_clean();
 int php_swoole_process_start(swWorker *process, zval *zobject);
@@ -348,6 +353,7 @@ void php_swoole_reactor_init();
 // shutdown
 void php_swoole_register_shutdown_function(const char *function);
 void php_swoole_register_shutdown_function_prepend(const char *function);
+void php_swoole_register_rshutdown_callback(swCallback cb, void *private_data);
 
 // event
 void php_swoole_event_init();
@@ -416,8 +422,6 @@ static sw_inline void swoole_set_property(zval *zobject, int property_id, void *
 
 int swoole_convert_to_fd(zval *zsocket);
 int swoole_convert_to_fd_ex(zval *zsocket, int *async);
-int swoole_register_rshutdown_function(swCallback func, int push_back);
-void swoole_call_rshutdown_function(void *arg);
 
 #ifdef SWOOLE_SOCKETS_SUPPORT
 php_socket *swoole_convert_to_socket(int sock);

src/server/worker.cc

@@ -642,11 +642,9 @@ static int swWorker_reactor_is_empty(swReactor *reactor)
     return SW_FALSE;
 }
 
-void swWorker_clean(void)
+void swWorker_clean_pipe_buffer(swServer *serv)
 {
     int i;
-    swServer *serv = (swServer *) SwooleWG.worker->pool->ptr;
-
     for (i = 0; i < serv->worker_num + serv->task_worker_num; i++)
     {
         swWorker *worker = swServer_get_worker(serv, i);
@@ -734,7 +732,7 @@ int swWorker_loop(swServer *serv, int worker_id)
     //main loop
     reactor->wait(reactor, NULL);
     //clear pipe buffer
-    swWorker_clean();
+    swWorker_clean_pipe_buffer(serv);
     //worker shutdown
     swWorker_onStop(serv);
     return SW_OK;

swoole.cc

@@ -28,10 +28,20 @@
 #include <ifaddrs.h>
 #include <sys/ioctl.h>
 
+#include <queue>
+
 ZEND_DECLARE_MODULE_GLOBALS(swoole)
 
 extern sapi_module_struct sapi_module;
 
+struct rshutdown_func
+{
+    swCallback callback;
+    void *private_data;
+};
+
+std::queue<rshutdown_func *> rshutdown_functions;
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_swoole_void, 0, 0, 0)
 ZEND_END_ARG_INFO()
 
@@ -275,26 +285,6 @@ void swoole_set_property_by_handle(uint32_t handle, int property_id, void *ptr)
     swoole_objects.property[property_id][handle] = ptr;
 }
 
-int swoole_register_rshutdown_function(swCallback func, int push_back)
-{
-    if (SWOOLE_G(rshutdown_functions) == NULL)
-    {
-        SWOOLE_G(rshutdown_functions) = swLinkedList_new(0, NULL);
-        if (SWOOLE_G(rshutdown_functions) == NULL)
-        {
-            return SW_ERR;
-        }
-    }
-    if (push_back)
-    {
-        return swLinkedList_append(SWOOLE_G(rshutdown_functions), (void*) func);
-    }
-    else
-    {
-        return swLinkedList_prepend(SWOOLE_G(rshutdown_functions), (void*) func);
-    }
-}
-
 void php_swoole_register_shutdown_function(const char *function)
 {
     php_shutdown_function_entry shutdown_function_entry;
@@ -327,6 +317,23 @@ void php_swoole_register_shutdown_function_prepend(const char *function)
     FREE_HASHTABLE(old_user_shutdown_function_names);
 }
 
+void php_swoole_register_rshutdown_callback(swCallback cb, void *private_data)
+{
+    rshutdown_func *rf = (rshutdown_func*) emalloc(sizeof(rshutdown_func));
+    rshutdown_functions.push(rf);
+}
+
+static void execute_rshutdown_callback()
+{
+    while(!rshutdown_functions.empty())
+    {
+        rshutdown_func *rf = rshutdown_functions.front();
+        rshutdown_functions.pop();
+        rf->callback(rf->private_data);
+        efree(rf);
+    }
+}
+
 static sw_inline zend_string* get_debug_print_backtrace(zend_long options, zend_long limit)
 {
     SW_PHP_OB_START(zoutput)
@@ -370,23 +377,6 @@ static void fatal_error(int code, const char *format, ...)
     exit(255);
 }
 
-void swoole_call_rshutdown_function(void *arg)
-{
-    if (SWOOLE_G(rshutdown_functions))
-    {
-        swLinkedList *rshutdown_functions = SWOOLE_G(rshutdown_functions);
-        swLinkedList_node *node = rshutdown_functions->head;
-        swCallback func = NULL;
-
-        while (node)
-        {
-            func = (swCallback) node->data;
-            func(arg);
-            node = node->next;
-        }
-    }
-}
-
 swoole_object_array swoole_objects;
 
 /* {{{ PHP_MINIT_FUNCTION
@@ -823,46 +813,15 @@ PHP_RINIT_FUNCTION(swoole)
 PHP_RSHUTDOWN_FUNCTION(swoole)
 {
     SWOOLE_G(req_status) = PHP_SWOOLE_RSHUTDOWN_BEGIN;
-    swoole_call_rshutdown_function(NULL);
+    execute_rshutdown_callback();
 
-    //clear pipe buffer
-    if (SwooleG.serv && swIsWorker())
-    {
-        swWorker_clean();
-    }
-
-    if (SwooleG.serv && SwooleG.serv->gs->start > 0 && !SwooleG.serv->gs->shutdown)
-    {
-        if (PG(last_error_message))
-        {
-            switch(PG(last_error_type))
-            {
-            case E_ERROR:
-            case E_CORE_ERROR:
-            case E_USER_ERROR:
-            case E_COMPILE_ERROR:
-                swoole_error_log(
-                    SW_LOG_ERROR, SW_ERROR_PHP_FATAL_ERROR, "Fatal error: %s in %s on line %d",
-                    PG(last_error_message), PG(last_error_file)?PG(last_error_file):"-", PG(last_error_lineno)
-                );
-                break;
-            default:
-                break;
-            }
-        }
-        else
-        {
-            swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SERVER_WORKER_TERMINATED, "worker process is terminated by exit()/die()");
-        }
-    }
-
-    swoole_async_coro_shutdown();
-    swoole_redis_server_shutdown();
-    swoole_coroutine_shutdown();
-    swoole_runtime_shutdown();
+    swoole_server_rshutdown();
+    swoole_async_coro_rshutdown();
+    swoole_redis_server_rshutdown();
+    swoole_coroutine_rshutdown();
+    swoole_runtime_rshutdown();
 
     SwooleG.running = 0;
-
     SWOOLE_G(req_status) = PHP_SWOOLE_RSHUTDOWN_END;
 
     return SUCCESS;

swoole_async_coro.cc

@@ -78,7 +78,7 @@ void swoole_async_coro_init(int module_number)
     SwooleAIO.max_thread_count = SW_AIO_THREAD_MAX_NUM;
 }
 
-void swoole_async_coro_shutdown()
+void swoole_async_coro_rshutdown()
 {
     for(auto i = request_cache_map.begin(); i != request_cache_map.end(); i++)
     {

swoole_coroutine_util.cc

@@ -262,7 +262,7 @@ void swoole_coroutine_util_init(int module_number)
     }
 }
 
-void swoole_coroutine_shutdown()
+void swoole_coroutine_rshutdown()
 {
     PHPCoroutine::shutdown();
 }

swoole_redis_server.cc

@@ -81,7 +81,7 @@ void swoole_redis_server_init(int module_number)
     zend_declare_class_constant_long(swoole_redis_server_ce, ZEND_STRL("MAP"), SW_REDIS_REPLY_MAP);
 }
 
-void swoole_redis_server_shutdown()
+void swoole_redis_server_rshutdown()
 {
     for (auto i = redis_handlers.begin(); i != redis_handlers.end(); i++)
     {

swoole_runtime.cc

@@ -173,7 +173,7 @@ struct real_func
     zval name;
 };
 
-void swoole_runtime_shutdown()
+void swoole_runtime_rshutdown()
 {
     if (!function_table)
     {

swoole_server.cc

@@ -466,6 +466,43 @@ static sw_inline zend_bool is_enable_coroutine(swServer *serv)
     }
 }
 
+void swoole_server_rshutdown()
+{
+    if (!SwooleG.serv)
+    {
+        return;
+    }
+
+    swServer *serv = SwooleG.serv;
+
+    swWorker_clean_pipe_buffer(serv);
+
+    if (serv->gs->start > 0 && !serv->gs->shutdown)
+    {
+        if (PG(last_error_message))
+        {
+            switch(PG(last_error_type))
+            {
+            case E_ERROR:
+            case E_CORE_ERROR:
+            case E_USER_ERROR:
+            case E_COMPILE_ERROR:
+                swoole_error_log(
+                    SW_LOG_ERROR, SW_ERROR_PHP_FATAL_ERROR, "Fatal error: %s in %s on line %d",
+                    PG(last_error_message), PG(last_error_file)?PG(last_error_file):"-", PG(last_error_lineno)
+                );
+                break;
+            default:
+                break;
+            }
+        }
+        else
+        {
+            swoole_error_log(SW_LOG_NOTICE, SW_ERROR_SERVER_WORKER_TERMINATED, "worker process is terminated by exit()/die()");
+        }
+    }
+}
+
 void swoole_server_init(int module_number)
 {
     SW_INIT_CLASS_ENTRY(swoole_server, "Swoole\\Server", "swoole_server", NULL, swoole_server_methods);
@@ -1500,6 +1537,8 @@ static void php_swoole_onWorkerStart(swServer *serv, int worker_id)
     zend_update_property_bool(swoole_server_ce, zserv, ZEND_STRL("taskworker"), worker_id >= serv->worker_num);
     zend_update_property_long(swoole_server_ce, zserv, ZEND_STRL("worker_pid"), getpid());
 
+    php_swoole_register_rshutdown_callback((swCallback) swWorker_clean_pipe_buffer, serv);
+
     if (!is_enable_coroutine(serv))
     {
         SwooleG.enable_coroutine = 0;