Return nanoseconds as zend_long on 64-bit, float on 32-bit, implement return array [s, ns]

weltling · weltling · commit 0f6f9657605a · 2018-01-02T22:22:24.000+01:00
Adjust tests

Move and rename test

Fix proto comment

Return array by default

Fix 32-bit and some more

Still provide symbols even if functionality is unavailable

Change typename

Add AIX specific pieces, untested

Improve 32-bit side once more

Rework macros

Few renames

Add comment

Remove unused code, a few other small things

Add comment

ws

Reword
diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
@@ -1454,10 +1454,9 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_http_response_code, 0, 0, 0)
 ZEND_END_ARG_INFO()
 /* }}} */
 /* {{{ hrtime.c */
-#if HRTIME_AVAILABLE
 ZEND_BEGIN_ARG_INFO(arginfo_hrtime, 0)
+	ZEND_ARG_INFO(0, get_as_numeric)
 ZEND_END_ARG_INFO()
-#endif
 /* }}} */
 /* {{{ html.c */
 ZEND_BEGIN_ARG_INFO_EX(arginfo_htmlspecialchars, 0, 0, 1)
@@ -2992,9 +2991,7 @@ static const zend_function_entry basic_functions[] = { /* {{{ */
 	PHP_FE(getrusage,														arginfo_getrusage)
 #endif
 
-#if HRTIME_AVAILABLE
 	PHP_FE(hrtime,															arginfo_hrtime)
-#endif
 
 #ifdef HAVE_GETTIMEOFDAY
 	PHP_FE(uniqid,															arginfo_uniqid)
@@ -3726,9 +3723,7 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */
 
 	BASIC_MINIT_SUBMODULE(random)
 
-#if HRTIME_AVAILABLE
 	BASIC_MINIT_SUBMODULE(hrtime)
-#endif
 
 	return SUCCESS;
 }
diff --git a/ext/standard/hrtime.c b/ext/standard/hrtime.c
@@ -22,153 +22,185 @@
 #include "zend_exceptions.h"
 #include "hrtime.h"
 
-#if HRTIME_AVAILABLE
-
-/* - timer.h ------------------------------------------------------------------------------------ */
-/* The following code is based on:
-   timer.h - Cross-platform timer library - Public Domain - 2011 Mattias Jansson / Rampant Pixels */
+/* {{{ */
+/* This file reuses code parts from the cross-platform timer library
+	Public Domain - 2011 Mattias Jansson / Rampant Pixels */
 
-#define TIMER_PLATFORM_POSIX   0
-#define TIMER_PLATFORM_WINDOWS 0
-#define TIMER_PLATFORM_APPLE   0
-#define TIMER_PLATFORM_HPUX    0
+#if PHP_HRTIME_PLATFORM_POSIX
 
-#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0) && defined(CLOCK_MONOTONIC)
+# include <unistd.h>
+# include <time.h>
+# include <string.h>
 
-#  undef  TIMER_PLATFORM_POSIX
-#  define TIMER_PLATFORM_POSIX 1
-#  include <unistd.h>
-#  include <time.h>
-#  include <string.h>
+#elif PHP_HRTIME_PLATFORM_WINDOWS
 
-#elif defined(_WIN32) || defined(_WIN64)
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
 
-#  undef  TIMER_PLATFORM_WINDOWS
-#  define TIMER_PLATFORM_WINDOWS 1
-#  define WIN32_LEAN_AND_MEAN
-#  include <windows.h>
+static uint64_t _timer_freq = 0;
+static double _timer_int = .0;
 
-#elif defined(__APPLE__)
+#elif PHP_HRTIME_PLATFORM_APPLE
 
-#  undef  TIMER_PLATFORM_APPLE
-#  define TIMER_PLATFORM_APPLE 1
-#  include <mach/mach_time.h>
-#  include <string.h>
+# include <mach/mach_time.h>
+# include <string.h>
 static mach_timebase_info_data_t _timerlib_info;
-static void absolutetime_to_nanoseconds (uint64_t mach_time, uint64_t* clock ) { *clock = mach_time * _timerlib_info.numer / _timerlib_info.denom; }
 
-#elif (defined(__hpux) || defined(hpux)) || ((defined(__sun__) || defined(__sun) || defined(sun)) && (defined(__SVR4) || defined(__svr4__)))
+#elif PHP_HRTIME_PLATFORM_HPUX
 
-#  undef  TIMER_PLATFORM_HPUX
-#  define TIMER_PLATFORM_HPUX 1
-#  include <sys/time.h>
+# include <sys/time.h>
+
+#elif PHP_HRTIME_PLATFORM_AIX
+
+# include <sys/time.h>
+# include <sys/systemcfg.h>
 
 #endif
 
-static uint64_t _timer_freq = 0;
+#define NANO_IN_SEC 1000000000
+/* }}} */
 
 static int _timer_init()
-{
-#if TIMER_PLATFORM_WINDOWS
+{/*{{{*/
+#if PHP_HRTIME_PLATFORM_WINDOWS
 
 	uint64_t unused;
 	if (!QueryPerformanceFrequency((LARGE_INTEGER*) &_timer_freq) ||
 		!QueryPerformanceCounter((LARGE_INTEGER*) &unused)) {
 		return -1;
 	}
+	_timer_int = 1.0 / _timer_freq;
 
-#elif TIMER_PLATFORM_APPLE
+#elif PHP_HRTIME_PLATFORM_APPLE
 
 	if (mach_timebase_info(&_timerlib_info)) {
 		return -1;
 	}
-	_timer_freq = 1000000000ULL;
 
-#elif TIMER_PLATFORM_POSIX
+#elif PHP_HRTIME_PLATFORM_POSIX
 
 	struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
+
 	if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
 		return -1;
 	}
-	_timer_freq = 1000000000ULL;
 
-#elif TIMER_PLATFORM_HPUX
-
-	_timer_freq = 1000000000ULL;
-
-#endif
+#elif PHP_HRTIME_PLATFORM_HPUX
 
-	return 0;
-}
-
-static uint64_t _timer_current()
-{
-#if TIMER_PLATFORM_WINDOWS
-
-	uint64_t curclock;
-	QueryPerformanceCounter((LARGE_INTEGER*) &curclock);
-	return curclock;
-
-#elif TIMER_PLATFORM_APPLE
-
-	uint64_t curclock = 0;
-	absolutetime_to_nanoseconds(mach_absolute_time(), &curclock);
-	return curclock;
-
-#elif TIMER_PLATFORM_POSIX
-
-	struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
-	if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
-		return -1;
-	}
-	return ((uint64_t) ts.tv_sec * 1000000000ULL) + ts.tv_nsec;
+	/* pass */
 
-#elif TIMER_PLATFORM_HPUX
+#elif PHP_HRTIME_PLATFORM_AIX
 
-	return (uint64_t) gethrtime();
+	/* pass */
 
+#else
+	/* Timer unavailable. */
+	return -1;
 #endif
-}
 
-/* - end of timer.h ----------------------------------------------------------------------------- */
+	return 0;
+}/*}}}*/
 
 /* {{{ */
 PHP_MINIT_FUNCTION(hrtime)
 {
-	if (_timer_init()) {
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to initialize internal timer");
+	if (0 > _timer_init()) {
+		php_error_docref(NULL, E_WARNING, "Failed to initialize high-resolution timer");
 		return FAILURE;
 	}
 
 	return SUCCESS;
 }
 /* }}} */
 
-/* {{{ */
-PHP_MSHUTDOWN_FUNCTION(hrtime)
-{
-	return SUCCESS;
-}
-/* }}} */
+static zend_always_inline php_hrtime_t _timer_current(void)
+{/*{{{*/
+#if PHP_HRTIME_PLATFORM_WINDOWS
+	uint64_t cur;
+	QueryPerformanceCounter((LARGE_INTEGER*) &cur);
+	return (php_hrtime_t)((double)cur * _timer_int * (double)NANO_IN_SEC);
+#elif PHP_HRTIME_PLATFORM_APPLE
+	return (php_hrtime_t)mach_absolute_time() * _timerlib_info.numer / _timerlib_info.denom;
+#elif PHP_HRTIME_PLATFORM_POSIX
+	struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
+	if (0 == clock_gettime(CLOCK_MONOTONIC, &ts)) {
+		return ((php_hrtime_t) ts.tv_sec * (php_hrtime_t)NANO_IN_SEC) + ts.tv_nsec;
+	}
+	return 0;
+#elif PHP_HRTIME_PLATFORM_HPUX
+	return (php_hrtime_t) gethrtime();
+#elif  PHP_HRTIME_PLATFORM_AIX
+	timebasestruct_t t;
+	read_wall_time(&t, TIMEBASE_SZ);
+	time_base_to_time(&t, TIMEBASE_SZ);
+	return (php_hrtime_t) t.tb_high * (php_hrtime_t)NANO_IN_SEC + t.tb_low;
+#else
+	return 0;
+#endif
+}/*}}}*/
+
+#if ZEND_ENABLE_ZVAL_LONG64
+#define PHP_RETURN_HRTIME(t) RETURN_LONG((zend_long)t)
+#else
+#ifdef _WIN32
+# define HRTIME_U64A(i, s, len) _ui64toa_s(i, s, len, 10)
+#else
+# define HRTIME_U64A(i, s, len) \
+	do { \
+		int st = snprintf(s, len, "%llu", i); \
+		s[st] = '\0'; \
+	} while (0)
+#endif
+#define PHP_RETURN_HRTIME(t) do { \
+	char _a[ZEND_LTOA_BUF_LEN]; \
+	double _d; \
+	HRTIME_U64A(t, _a, ZEND_LTOA_BUF_LEN); \
+	_d = zend_strtod(_a, NULL); \
+	RETURN_DOUBLE(_d); \
+	} while (0)
+#endif
 
-/* {{{ proto float hrtime()
-   Returns a float containing the current high-resolution time in seconds
-   counted from an arbitrary point in time */
+/* {{{ proto mixed hrtime([bool get_as_numu = false])
+	Returns an array of integers in form [seconds, nanoseconds] counted
+	from an arbitrary point in time. If an optional boolean argument is
+	passed, returns an integer on 64-bit platforms or float on 32-bit
+	containing the current high-resolution time in nanoseconds */
 PHP_FUNCTION(hrtime)
 {
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	uint64_t current_time = _timer_current();
-
-	if (UNEXPECTED(current_time == -1)) {
-		zend_throw_exception(zend_ce_error, "Failed to get current system time", 0);
-		return;
+#if HRTIME_AVAILABLE
+	zend_bool get_as_num = 0;
+	php_hrtime_t t = _timer_current();
+
+	ZEND_PARSE_PARAMETERS_START(0, 1)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_BOOL(get_as_num)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (!get_as_num) {
+		/* TODO On 32-bit care about millenium bug. */
+		array_init(return_value);
+		add_next_index_long(return_value, (zend_long)(t / (php_hrtime_t)NANO_IN_SEC));
+		add_next_index_long(return_value, (zend_long)(t % (php_hrtime_t)NANO_IN_SEC));
+	} else {
+		PHP_RETURN_HRTIME(t);
 	}
-
-	RETURN_DOUBLE((double) current_time / _timer_freq);
+#else
+	RETURN_LONG(0);
+#endif
 }
 /* }}} */
 
-#endif /* HRTIME_AVAILABLE */
+PHPAPI php_hrtime_t php_hrtime_current(void)
+{/*{{{*/
+	return _timer_current();
+}/*}}}*/
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
+
diff --git a/ext/standard/hrtime.h b/ext/standard/hrtime.h
@@ -21,23 +21,38 @@
 #ifndef HRTIME_H
 #define HRTIME_H
 
+#define PHP_HRTIME_PLATFORM_POSIX   0
+#define PHP_HRTIME_PLATFORM_WINDOWS 0
+#define PHP_HRTIME_PLATFORM_APPLE   0
+#define PHP_HRTIME_PLATFORM_HPUX    0
+#define PHP_HRTIME_PLATFORM_AIX     0
+
 #if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0) && defined(CLOCK_MONOTONIC)
-#define HRTIME_AVAILABLE 1
+/* XXX might need additional sysconf check. */
+# undef  PHP_HRTIME_PLATFORM_POSIX
+# define PHP_HRTIME_PLATFORM_POSIX 1
 #elif defined(_WIN32) || defined(_WIN64)
-#define HRTIME_AVAILABLE 1
+# undef  PHP_HRTIME_PLATFORM_WINDOWS
+# define PHP_HRTIME_PLATFORM_WINDOWS 1
 #elif defined(__APPLE__)
-#define HRTIME_AVAILABLE 1
+# undef  PHP_HRTIME_PLATFORM_APPLE
+# define PHP_HRTIME_PLATFORM_APPLE 1
 #elif (defined(__hpux) || defined(hpux)) || ((defined(__sun__) || defined(__sun) || defined(sun)) && (defined(__SVR4) || defined(__svr4__)))
-#define HRTIME_AVAILABLE 1
-#else
-#define HRTIME_AVAILABLE 0
+# undef  PHP_HRTIME_PLATFORM_HPUX
+# define PHP_HRTIME_PLATFORM_HPUX 1
+#elif defined(_AIX)
+# undef  PHP_HRTIME_PLATFORM_AIX
+# define PHP_HRTIME_PLATFORM_AIX 1
 #endif
 
-#if HRTIME_AVAILABLE
-	PHP_MINIT_FUNCTION(hrtime);
-	PHP_MSHUTDOWN_FUNCTION(hrtime);
+#define HRTIME_AVAILABLE (PHP_HRTIME_PLATFORM_POSIX || PHP_HRTIME_PLATFORM_WINDOWS || PHP_HRTIME_PLATFORM_APPLE || PHP_HRTIME_PLATFORM_HPUX || PHP_HRTIME_PLATFORM_AIX)
+
+typedef uint64_t php_hrtime_t;
+
+PHPAPI php_hrtime_t php_hrtime_current(void);
+
+PHP_MINIT_FUNCTION(hrtime);
 
-	PHP_FUNCTION(hrtime);
-#endif /* HRTIME_AVAILABLE */
+PHP_FUNCTION(hrtime);
 
 #endif /* HRTIME_H */
diff --git a/ext/standard/tests/hrtime/hrtime.phpt b/ext/standard/tests/hrtime/hrtime.phpt
@@ -3,20 +3,24 @@ Test hrtime() aligns with microtime()
 --FILE--
 <?php
 
-$hrtime = hrtime();
-$microtime = microtime(1);
+$m0 = microtime(true);
+$h0 = hrtime(true);
+for ($i = 0; $i < 1024*1024; $i++);
+$h1 = hrtime(true);
+$m1 = microtime(true);
 
-usleep(500000);
+$d0 = ($m1 - $m0)*1000000000.0;
+$d1 = $h1 - $h0;
 
-$hrdiff = hrtime() - $hrtime;
-$microdiff = microtime(1) - $microtime;
+/* Relative uncertainty. */
+$d = abs($d0 - $d1)/$d1;
 
-if (abs($hrdiff - $microdiff) > 0.0001) {
-    print "fail";
+if ($d > 0.05) {
+	print "FAIL, $d";
 } else {
-    print "OK";
+	print "OK, $d";
 }
 
 ?>
---EXPECT--
-OK
+--EXPECTF--
+OK, %f
diff --git a/ext/standard/tests/hrtime/hrtime_array.phpt b/ext/standard/tests/hrtime/hrtime_array.phpt
diff --git a/ext/standard/tests/hrtime/hrtime_error.phpt b/ext/standard/tests/hrtime/hrtime_error.phpt
