[ViewVC] Diff of: cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.522 by root, Tue Dec 31 06:02:28 2019 UTC vs.
Revision 1.523 by root, Tue Jan 21 23:52:35 2020 UTC

…		…
579	#define MIN_INTERVAL 0.0001220703125 /* 1/2*13, good till 4000 /	579	#define MIN_INTERVAL 0.0001220703125 /* 1/2*13, good till 4000 /
580	/#define MIN_INTERVAL 0.00000095367431640625 / 1/2*20, good till 2200 /	580	/#define MIN_INTERVAL 0.00000095367431640625 / 1/2*20, good till 2200 /
581		581
582	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	582	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
583	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	583	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
		584	#define MAX_BLOCKTIME2 1500001.07 /* same, but when timerfd is used to detect jumps, also safe delay to not overflow */
584		585
585	/* find a portable timestamp that is "always" in the future but fits into time_t.	586	/* find a portable timestamp that is "always" in the future but fits into time_t.
586	* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,	587	* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
587	* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */	588	* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
588	#define EV_TSTAMP_HUGE \	589	#define EV_TSTAMP_HUGE \
…		…
644		645
645	#ifndef ECB_H	646	#ifndef ECB_H
646	#define ECB_H	647	#define ECB_H
647		648
648	/* 16 bits major, 16 bits minor */	649	/* 16 bits major, 16 bits minor */
649	#define ECB_VERSION 0x00010006	650	#define ECB_VERSION 0x00010008
		651
		652	#include <string.h> /* for memcpy */
650		653
651	#ifdef _WIN32	654	#ifdef _WIN32
652	typedef signed char int8_t;	655	typedef signed char int8_t;
653	typedef unsigned char uint8_t;	656	typedef unsigned char uint8_t;
		657	typedef signed char int_fast8_t;
		658	typedef unsigned char uint_fast8_t;
654	typedef signed short int16_t;	659	typedef signed short int16_t;
655	typedef unsigned short uint16_t;	660	typedef unsigned short uint16_t;
		661	typedef signed int int_fast16_t;
		662	typedef unsigned int uint_fast16_t;
656	typedef signed int int32_t;	663	typedef signed int int32_t;
657	typedef unsigned int uint32_t;	664	typedef unsigned int uint32_t;
		665	typedef signed int int_fast32_t;
		666	typedef unsigned int uint_fast32_t;
658	#if __GNUC__	667	#if __GNUC__
659	typedef signed long long int64_t;	668	typedef signed long long int64_t;
660	typedef unsigned long long uint64_t;	669	typedef unsigned long long uint64_t;
661	#else /* _MSC_VER \|\| __BORLANDC__ */	670	#else /* _MSC_VER \|\| __BORLANDC__ */
662	typedef signed __int64 int64_t;	671	typedef signed __int64 int64_t;
663	typedef unsigned __int64 uint64_t;	672	typedef unsigned __int64 uint64_t;
664	#endif	673	#endif
		674	typedef int64_t int_fast64_t;
		675	typedef uint64_t uint_fast64_t;
665	#ifdef _WIN64	676	#ifdef _WIN64
666	#define ECB_PTRSIZE 8	677	#define ECB_PTRSIZE 8
667	typedef uint64_t uintptr_t;	678	typedef uint64_t uintptr_t;
668	typedef int64_t intptr_t;	679	typedef int64_t intptr_t;
669	#else	680	#else
…		…
680	#endif	691	#endif
681	#endif	692	#endif
682		693
683	#define ECB_GCC_AMD64 (__amd64 \|\| __amd64__ \|\| __x86_64 \|\| __x86_64__)	694	#define ECB_GCC_AMD64 (__amd64 \|\| __amd64__ \|\| __x86_64 \|\| __x86_64__)
684	#define ECB_MSVC_AMD64 (_M_AMD64 \|\| _M_X64)	695	#define ECB_MSVC_AMD64 (_M_AMD64 \|\| _M_X64)
		696
		697	#ifndef ECB_OPTIMIZE_SIZE
		698	#if __OPTIMIZE_SIZE__
		699	#define ECB_OPTIMIZE_SIZE 1
		700	#else
		701	#define ECB_OPTIMIZE_SIZE 0
		702	#endif
		703	#endif
685		704
686	/* work around x32 idiocy by defining proper macros */	705	/* work around x32 idiocy by defining proper macros */
687	#if ECB_GCC_AMD64 \|\| ECB_MSVC_AMD64	706	#if ECB_GCC_AMD64 \|\| ECB_MSVC_AMD64
688	#if _ILP32	707	#if _ILP32
689	#define ECB_AMD64_X32 1	708	#define ECB_AMD64_X32 1
…		…
1196	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) \| (x << count); }	1215	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) \| (x << count); }
1197	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) \| (x >> count); }	1216	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) \| (x >> count); }
1198	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) \| (x << count); }	1217	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) \| (x << count); }
1199	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) \| (x >> count); }	1218	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) \| (x >> count); }
1200		1219
		1220	#if ECB_CPP
		1221
		1222	inline uint8_t ecb_ctz (uint8_t v) { return ecb_ctz32 (v); }
		1223	inline uint16_t ecb_ctz (uint16_t v) { return ecb_ctz32 (v); }
		1224	inline uint32_t ecb_ctz (uint32_t v) { return ecb_ctz32 (v); }
		1225	inline uint64_t ecb_ctz (uint64_t v) { return ecb_ctz64 (v); }
		1226
		1227	inline bool ecb_is_pot (uint8_t v) { return ecb_is_pot32 (v); }
		1228	inline bool ecb_is_pot (uint16_t v) { return ecb_is_pot32 (v); }
		1229	inline bool ecb_is_pot (uint32_t v) { return ecb_is_pot32 (v); }
		1230	inline bool ecb_is_pot (uint64_t v) { return ecb_is_pot64 (v); }
		1231
		1232	inline int ecb_ld (uint8_t v) { return ecb_ld32 (v); }
		1233	inline int ecb_ld (uint16_t v) { return ecb_ld32 (v); }
		1234	inline int ecb_ld (uint32_t v) { return ecb_ld32 (v); }
		1235	inline int ecb_ld (uint64_t v) { return ecb_ld64 (v); }
		1236
		1237	inline int ecb_popcount (uint8_t v) { return ecb_popcount32 (v); }
		1238	inline int ecb_popcount (uint16_t v) { return ecb_popcount32 (v); }
		1239	inline int ecb_popcount (uint32_t v) { return ecb_popcount32 (v); }
		1240	inline int ecb_popcount (uint64_t v) { return ecb_popcount64 (v); }
		1241
		1242	inline uint8_t ecb_bitrev (uint8_t v) { return ecb_bitrev8 (v); }
		1243	inline uint16_t ecb_bitrev (uint16_t v) { return ecb_bitrev16 (v); }
		1244	inline uint32_t ecb_bitrev (uint32_t v) { return ecb_bitrev32 (v); }
		1245
		1246	inline uint8_t ecb_rotl (uint8_t v, unsigned int count) { return ecb_rotl8 (v, count); }
		1247	inline uint16_t ecb_rotl (uint16_t v, unsigned int count) { return ecb_rotl16 (v, count); }
		1248	inline uint32_t ecb_rotl (uint32_t v, unsigned int count) { return ecb_rotl32 (v, count); }
		1249	inline uint64_t ecb_rotl (uint64_t v, unsigned int count) { return ecb_rotl64 (v, count); }
		1250
		1251	inline uint8_t ecb_rotr (uint8_t v, unsigned int count) { return ecb_rotr8 (v, count); }
		1252	inline uint16_t ecb_rotr (uint16_t v, unsigned int count) { return ecb_rotr16 (v, count); }
		1253	inline uint32_t ecb_rotr (uint32_t v, unsigned int count) { return ecb_rotr32 (v, count); }
		1254	inline uint64_t ecb_rotr (uint64_t v, unsigned int count) { return ecb_rotr64 (v, count); }
		1255
		1256	#endif
		1257
1201	#if ECB_GCC_VERSION(4,3) \|\| (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))	1258	#if ECB_GCC_VERSION(4,3) \|\| (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
1202	#if ECB_GCC_VERSION(4,8) \|\| ECB_CLANG_BUILTIN(__builtin_bswap16)	1259	#if ECB_GCC_VERSION(4,8) \|\| ECB_CLANG_BUILTIN(__builtin_bswap16)
1203	#define ecb_bswap16(x) __builtin_bswap16 (x)	1260	#define ecb_bswap16(x) __builtin_bswap16 (x)
1204	#else	1261	#else
1205	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)	1262	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
…		…
1276	ecb_inline ecb_const ecb_bool ecb_big_endian (void);	1333	ecb_inline ecb_const ecb_bool ecb_big_endian (void);
1277	ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }	1334	ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
1278	ecb_inline ecb_const ecb_bool ecb_little_endian (void);	1335	ecb_inline ecb_const ecb_bool ecb_little_endian (void);
1279	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }	1336	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
1280		1337
		1338	/*****************************************************************************/
		1339	/* unaligned load/store */
		1340
		1341	ecb_inline uint_fast16_t ecb_be_u16_to_host (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
		1342	ecb_inline uint_fast32_t ecb_be_u32_to_host (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
		1343	ecb_inline uint_fast64_t ecb_be_u64_to_host (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
		1344
		1345	ecb_inline uint_fast16_t ecb_le_u16_to_host (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
		1346	ecb_inline uint_fast32_t ecb_le_u32_to_host (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
		1347	ecb_inline uint_fast64_t ecb_le_u64_to_host (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
		1348
		1349	ecb_inline uint_fast16_t ecb_peek_u16_u (const void *ptr) { uint16_t v; memcpy (&v, ptr, sizeof (v)); return v; }
		1350	ecb_inline uint_fast32_t ecb_peek_u32_u (const void *ptr) { uint32_t v; memcpy (&v, ptr, sizeof (v)); return v; }
		1351	ecb_inline uint_fast64_t ecb_peek_u64_u (const void *ptr) { uint64_t v; memcpy (&v, ptr, sizeof (v)); return v; }
		1352
		1353	ecb_inline uint_fast16_t ecb_peek_be_u16_u (const void *ptr) { return ecb_be_u16_to_host (ecb_peek_u16_u (ptr)); }
		1354	ecb_inline uint_fast32_t ecb_peek_be_u32_u (const void *ptr) { return ecb_be_u32_to_host (ecb_peek_u32_u (ptr)); }
		1355	ecb_inline uint_fast64_t ecb_peek_be_u64_u (const void *ptr) { return ecb_be_u64_to_host (ecb_peek_u64_u (ptr)); }
		1356
		1357	ecb_inline uint_fast16_t ecb_peek_le_u16_u (const void *ptr) { return ecb_le_u16_to_host (ecb_peek_u16_u (ptr)); }
		1358	ecb_inline uint_fast32_t ecb_peek_le_u32_u (const void *ptr) { return ecb_le_u32_to_host (ecb_peek_u32_u (ptr)); }
		1359	ecb_inline uint_fast64_t ecb_peek_le_u64_u (const void *ptr) { return ecb_le_u64_to_host (ecb_peek_u64_u (ptr)); }
		1360
		1361	ecb_inline uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
		1362	ecb_inline uint_fast32_t ecb_host_to_be_u32 (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
		1363	ecb_inline uint_fast64_t ecb_host_to_be_u64 (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
		1364
		1365	ecb_inline uint_fast16_t ecb_host_to_le_u16 (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
		1366	ecb_inline uint_fast32_t ecb_host_to_le_u32 (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
		1367	ecb_inline uint_fast64_t ecb_host_to_le_u64 (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
		1368
		1369	ecb_inline void ecb_poke_u16_u (void *ptr, uint16_t v) { memcpy (ptr, &v, sizeof (v)); }
		1370	ecb_inline void ecb_poke_u32_u (void *ptr, uint32_t v) { memcpy (ptr, &v, sizeof (v)); }
		1371	ecb_inline void ecb_poke_u64_u (void *ptr, uint64_t v) { memcpy (ptr, &v, sizeof (v)); }
		1372
		1373	ecb_inline void ecb_poke_be_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_be_u16 (v)); }
		1374	ecb_inline void ecb_poke_be_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_be_u32 (v)); }
		1375	ecb_inline void ecb_poke_be_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_be_u64 (v)); }
		1376
		1377	ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); }
		1378	ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); }
		1379	ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); }
		1380
		1381	#if ECB_CPP
		1382
		1383	inline uint8_t ecb_bswap (uint8_t v) { return v; }
		1384	inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
		1385	inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
		1386	inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
		1387
		1388	template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
		1389	template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
		1390	template<typename T> inline T ecb_peek (const void ptr) { return (const T *)ptr; }
		1391	template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); }
		1392	template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); }
		1393	template<typename T> inline T ecb_peek_u (const void *ptr) { T v; memcpy (&v, ptr, sizeof (v)); return v; }
		1394	template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); }
		1395	template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); }
		1396
		1397	template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
		1398	template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
		1399	template<typename T> inline void ecb_poke (void ptr, T v) { (T *)ptr = v; }
		1400	template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
		1401	template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
		1402	template<typename T> inline void ecb_poke_u (void *ptr, T v) { memcpy (ptr, &v, sizeof (v)); }
		1403	template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); }
		1404	template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
		1405
		1406	#endif
		1407
		1408	/*****************************************************************************/
		1409
1281	#if ECB_GCC_VERSION(3,0) \|\| ECB_C99	1410	#if ECB_GCC_VERSION(3,0) \|\| ECB_C99
1282	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))	1411	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
1283	#else	1412	#else
1284	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))	1413	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
1285	#endif	1414	#endif
…		…
1308	return N;	1437	return N;
1309	}	1438	}
1310	#else	1439	#else
1311	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	1440	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1312	#endif	1441	#endif
		1442
		1443	/*****************************************************************************/
1313		1444
1314	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);	1445	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
1315	ecb_function_ ecb_const uint32_t	1446	ecb_function_ ecb_const uint32_t
1316	ecb_binary16_to_binary32 (uint32_t x)	1447	ecb_binary16_to_binary32 (uint32_t x)
1317	{	1448	{
…		…
1426	\|\| defined __sh__ \	1557	\|\| defined __sh__ \
1427	\|\| defined _M_IX86 \|\| defined ECB_MSVC_AMD64 \|\| defined _M_IA64 \	1558	\|\| defined _M_IX86 \|\| defined ECB_MSVC_AMD64 \|\| defined _M_IA64 \
1428	\|\| (defined __arm__ && (defined __ARM_EABI__ \|\| defined __EABI__ \|\| defined __VFP_FP__ \|\| defined _WIN32_WCE \|\| defined __ANDROID__)) \	1559	\|\| (defined __arm__ && (defined __ARM_EABI__ \|\| defined __EABI__ \|\| defined __VFP_FP__ \|\| defined _WIN32_WCE \|\| defined __ANDROID__)) \
1429	\|\| defined __aarch64__	1560	\|\| defined __aarch64__
1430	#define ECB_STDFP 1	1561	#define ECB_STDFP 1
1431	#include <string.h> /* for memcpy */
1432	#else	1562	#else
1433	#define ECB_STDFP 0	1563	#define ECB_STDFP 0
1434	#endif	1564	#endif
1435		1565
1436	#ifndef ECB_NO_LIBM	1566	#ifndef ECB_NO_LIBM
…		…
2903	static void	3033	static void
2904	timerfdcb (EV_P_ ev_io *iow, int revents)	3034	timerfdcb (EV_P_ ev_io *iow, int revents)
2905	{	3035	{
2906	struct itimerspec its = { 0 };	3036	struct itimerspec its = { 0 };
2907		3037
2908	/* since we can't easily come zup with a (portable) maximum value of time_t,	3038	its.it_value.tv_sec = ev_rt_now + (int)MAX_BLOCKTIME2;
2909	* we wake up once per month, which hopefully is rare enough to not
2910	* be a problem. */
2911	its.it_value.tv_sec = ev_rt_now + 86400 * 30;
2912	timerfd_settime (timerfd, TFD_TIMER_ABSTIME \| TFD_TIMER_CANCEL_ON_SET, &its, 0);	3039	timerfd_settime (timerfd, TFD_TIMER_ABSTIME \| TFD_TIMER_CANCEL_ON_SET, &its, 0);
2913		3040
2914	ev_rt_now = ev_time ();	3041	ev_rt_now = ev_time ();
2915	/* periodics_reschedule only needs ev_rt_now */	3042	/* periodics_reschedule only needs ev_rt_now */
2916	/* but maybe in the future we want the full treatment. */	3043	/* but maybe in the future we want the full treatment. */
…		…
3963		4090
3964	if (ecb_expect_true (!(flags & EVRUN_NOWAIT \|\| idleall \|\| !activecnt \|\| pipe_write_skipped)))	4091	if (ecb_expect_true (!(flags & EVRUN_NOWAIT \|\| idleall \|\| !activecnt \|\| pipe_write_skipped)))
3965	{	4092	{
3966	waittime = EV_TS_CONST (MAX_BLOCKTIME);	4093	waittime = EV_TS_CONST (MAX_BLOCKTIME);
3967		4094
		4095	#if EV_USE_TIMERFD
		4096	/* sleep a lot longer when we can reliably detect timejumps */
		4097	if (ecb_expect_true (timerfd >= 0))
		4098	waittime = EV_TS_CONST (MAX_BLOCKTIME2);
		4099	#endif
		4100
3968	if (timercnt)	4101	if (timercnt)
3969	{	4102	{
3970	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	4103	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3971	if (waittime > to) waittime = to;	4104	if (waittime > to) waittime = to;
3972	}	4105	}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.c (file contents): Revision 1.522 by root, Tue Dec 31 06:02:28 2019 UTC vs. Revision 1.523 by root, Tue Jan 21 23:52:35 2020 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.522 by root, Tue Dec 31 06:02:28 2019 UTC vs.
Revision 1.523 by root, Tue Jan 21 23:52:35 2020 UTC