Optimize swoole.h, remove sched.h/<sys/time.h> includes. Remove gettimeofday and use C++ chrono instead

Author: matyhtf

ext-src/swoole_runtime.cc

@@ -1501,7 +1501,7 @@ static void hook_pdo_driver(uint32_t flags) {
         }
     } else {
         if (runtime_hook_flags & PHPCoroutine::HOOK_PDO_FIREBIRD) {
-        	swoole_firebird_set_blocking(true);
+            swoole_firebird_set_blocking(true);
         }
     }
 #endif
@@ -1809,9 +1809,11 @@ static PHP_FUNCTION(swoole_sleep) {
 
 static PHP_FUNCTION(swoole_usleep) {
     zend_long num;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &num) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_LONG(num)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
+
     if (num < 0) {
         php_error_docref(nullptr, E_WARNING, "Number of seconds must be greater than or equal to 0");
         RETURN_FALSE;
@@ -1826,9 +1828,11 @@ static PHP_FUNCTION(swoole_usleep) {
 
 static PHP_FUNCTION(swoole_time_nanosleep) {
     zend_long tv_sec, tv_nsec;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll", &tv_sec, &tv_nsec) == FAILURE) {
-        RETURN_FALSE;
-    }
+
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+    Z_PARAM_LONG(tv_sec)
+    Z_PARAM_LONG(tv_nsec)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
     if (tv_sec < 0) {
         php_error_docref(nullptr, E_WARNING, "The seconds value must be greater than 0");
@@ -1861,41 +1865,34 @@ static PHP_FUNCTION(swoole_time_nanosleep) {
 
 static PHP_FUNCTION(swoole_time_sleep_until) {
     double d_ts;
-    timeval tm;
-    timespec php_req, php_rem;
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "d", &d_ts) == FAILURE) {
-        RETURN_FALSE;
-    }
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+    Z_PARAM_DOUBLE(d_ts)
+    ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
-    if (gettimeofday(&tm, nullptr) != 0) {
+    if (!std::isfinite(d_ts) || d_ts < 0) {
+        php_error_docref(nullptr, E_WARNING, "Invalid timestamp: must be a positive finite number");
         RETURN_FALSE;
     }
 
-    double c_ts = d_ts - tm.tv_sec - tm.tv_usec / 1000000.00;
-    if (c_ts < 0) {
-        php_error_docref(nullptr, E_WARNING, "Sleep until to time is less than current time");
-        RETURN_FALSE;
-    }
+    using namespace std::chrono;
+    using dseconds = duration<double>;
+
+    const auto now = system_clock::now();
+    const auto target_duration = duration_cast<system_clock::duration>(dseconds(d_ts));
+    const auto target_time = system_clock::time_point(target_duration);
 
-    php_req.tv_sec = (time_t) c_ts;
-    if (php_req.tv_sec > c_ts) {
-        php_req.tv_sec--;
+    if (target_time <= now) {
+        php_error_docref(NULL, E_WARNING, "Argument #1 ($timestamp) must be greater than or equal to the current time");
+        RETURN_FALSE;
     }
-    php_req.tv_nsec = (long) ((c_ts - php_req.tv_sec) * 1000000000.00);
 
-    double _time = (double) php_req.tv_sec + (double) php_req.tv_nsec / 1000000000.00;
+    const auto sleep_duration = target_time - now;
     if (Coroutine::get_current()) {
-        System::sleep(_time);
+        const double sleep_seconds = duration_cast<dseconds>(sleep_duration).count();
+        System::sleep(sleep_seconds);
     } else {
-        while (nanosleep(&php_req, &php_rem)) {
-            if (errno == EINTR) {
-                php_req.tv_sec = php_rem.tv_sec;
-                php_req.tv_nsec = php_rem.tv_nsec;
-            } else {
-                RETURN_FALSE;
-            }
-        }
+        std::this_thread::sleep_until(target_time);
     }
     RETURN_TRUE;
 }

include/swoole.h

@@ -31,7 +31,11 @@
 #define SW_EXTERN_C_END
 #endif
 
-#ifndef _GNU_SOURCE
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+
+#if defined(__linux__) && !defined(_GNU_SOURCE)
 #define _GNU_SOURCE
 #endif
 
@@ -49,13 +53,11 @@
 #include <cstring>
 #include <climits>
 #include <unistd.h>
-#include <sched.h> /* sched_yield() */
 #include <pthread.h>
 #include <inttypes.h>
 
 #include <sys/uio.h>
 #include <sys/utsname.h>
-#include <sys/time.h>
 
 #include <string>
 #include <memory>
@@ -492,9 +494,6 @@ enum swTraverseOperation {
     SW_TRAVERSE_STOP = 2,
 };
 
-//-------------------------------------------------------------------------------
-#define sw_yield() sched_yield()
-
 //------------------------------Base--------------------------------
 #ifndef uchar
 typedef unsigned char uchar;

include/swoole_util.h

@@ -20,6 +20,7 @@
 #include <cstdio>
 #include <cstdarg>
 #include <cassert>
+#include <ctime>
 
 #include <string>
 #include <memory>
@@ -72,14 +73,11 @@ static inline long time(bool steady = false) {
 }
 
 static inline long get_timezone() {
-#ifdef __linux__
-    return timezone;
-#else
-    struct timezone tz;
-    struct timeval tv;
-    gettimeofday(&tv, &tz);
-    return tz.tz_minuteswest * 60;
-#endif
+    using namespace std::chrono;
+    auto now_time_t = system_clock::to_time_t(system_clock::now());
+    std::tm local_tm{};
+    localtime_r(&now_time_t, &local_tm);
+    return local_tm.tm_gmtoff;
 }
 
 class DeferTask {

src/core/base.cc

@@ -29,6 +29,7 @@
 
 #include <list>
 #include <set>
+#include <chrono>
 #include <random>
 
 #include "swoole_string.h"
@@ -956,8 +957,7 @@ std::string intersection(const std::vector<std::string> &vec1, std::set<std::str
 }
 
 double microtime() {
-    timeval t;
-    gettimeofday(&t, nullptr);
-    return (double) t.tv_sec + ((double) t.tv_usec / 1000000);
+    using namespace std::chrono;
+    return duration_cast<duration<double>>(system_clock::now().time_since_epoch()).count();
 }
 };  // namespace swoole

src/core/misc.cc

@@ -16,6 +16,8 @@
 
 #include "swoole.h"
 
+#include <thread>
+
 void sw_spinlock(sw_atomic_t *lock) {
     uint32_t i, n;
     while (true) {
@@ -33,7 +35,7 @@ void sw_spinlock(sw_atomic_t *lock) {
                 }
             }
         }
-        sw_yield();
+        std::this_thread::yield();
     }
 }
 

src/memory/table.cc

@@ -18,6 +18,8 @@
 #include "swoole_hash.h"
 #include "swoole_util.h"
 
+#include <thread>
+
 namespace swoole {
 
 Table *Table::make(uint32_t rows_size, float conflict_proportion) {
@@ -263,7 +265,7 @@ void TableRow::lock() {
             swoole_warning("timeout, force unlock");
             goto _success;
         }
-        sw_yield();
+        std::this_thread::yield();
     }
 }
 

src/os/timer.cc

@@ -18,6 +18,7 @@
 #include "swoole_signal.h"
 
 #include <csignal>
+#include <sys/time.h>
 
 namespace swoole {
 static int SystemTimer_set(Timer *timer, long next_msec);
@@ -29,34 +30,12 @@ void Timer::init_with_system_timer() {
 }
 
 static int SystemTimer_set(Timer *timer, long next_msec) {
-    itimerval timer_set;
-    timeval now;
-    if (gettimeofday(&now, nullptr) < 0) {
-        swoole_sys_warning("gettimeofday() failed");
-        return SW_ERR;
-    }
-
+    itimerval timer_set{};
     if (next_msec > 0) {
-        int sec = next_msec / 1000;
-        int msec = next_msec % 1000;
-        timer_set.it_interval.tv_sec = sec;
-        timer_set.it_interval.tv_usec = msec * 1000;
-        timer_set.it_value.tv_sec = sec;
-        timer_set.it_value.tv_usec = timer_set.it_interval.tv_usec;
-
-        if (timer_set.it_value.tv_usec > 1e6) {
-            timer_set.it_value.tv_usec = timer_set.it_value.tv_usec - 1e6;
-            timer_set.it_value.tv_sec += 1;
-        }
-    } else {
-        timer_set = {};
-    }
-
-    if (setitimer(ITIMER_REAL, &timer_set, nullptr) < 0) {
-        swoole_sys_warning("setitimer() failed");
-        return SW_ERR;
+        timer_set.it_interval = {next_msec / 1000, (next_msec % 1000) * 1000};
+        timer_set.it_value = timer_set.it_interval;
     }
-    return SW_OK;
+    return setitimer(ITIMER_REAL, &timer_set, nullptr) < 0 ? SW_ERR : SW_OK;
 }
 
 void realtime_get(timespec *time) {