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

Comparing libev/ev.c (file contents):
Revision 1.501 by root, Mon Jul 1 21:47:42 2019 UTC vs.
Revision 1.526 by root, Wed Jan 22 17:11:33 2020 UTC

…		…
117	# define EV_USE_EPOLL 0	117	# define EV_USE_EPOLL 0
118	# endif	118	# endif
119		119
120	# if HAVE_LINUX_AIO_ABI_H	120	# if HAVE_LINUX_AIO_ABI_H
121	# ifndef EV_USE_LINUXAIO	121	# ifndef EV_USE_LINUXAIO
122	# define EV_USE_LINUXAIO EV_FEATURE_BACKENDS	122	# define EV_USE_LINUXAIO 0 /* was: EV_FEATURE_BACKENDS, always off by default */
123	# endif	123	# endif
124	# else	124	# else
125	# undef EV_USE_LINUXAIO	125	# undef EV_USE_LINUXAIO
126	# define EV_USE_LINUXAIO 0	126	# define EV_USE_LINUXAIO 0
127	# endif	127	# endif
128		128
		129	# if HAVE_LINUX_FS_H && HAVE_SYS_TIMERFD_H && HAVE_KERNEL_RWF_T
		130	# ifndef EV_USE_IOURING
		131	# define EV_USE_IOURING EV_FEATURE_BACKENDS
		132	# endif
		133	# else
		134	# undef EV_USE_IOURING
		135	# define EV_USE_IOURING 0
		136	# endif
		137
129	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H	138	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
130	# ifndef EV_USE_KQUEUE	139	# ifndef EV_USE_KQUEUE
131	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS	140	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS
132	# endif	141	# endif
133	# else	142	# else
…		…
168	# endif	177	# endif
169	# else	178	# else
170	# undef EV_USE_EVENTFD	179	# undef EV_USE_EVENTFD
171	# define EV_USE_EVENTFD 0	180	# define EV_USE_EVENTFD 0
172	# endif	181	# endif
173		182
		183	# if HAVE_SYS_TIMERFD_H
		184	# ifndef EV_USE_TIMERFD
		185	# define EV_USE_TIMERFD EV_FEATURE_OS
		186	# endif
		187	# else
		188	# undef EV_USE_TIMERFD
		189	# define EV_USE_TIMERFD 0
		190	# endif
		191
174	#endif	192	#endif
175		193
176	/* OS X, in its infinite idiocy, actually HARDCODES	194	/* OS X, in its infinite idiocy, actually HARDCODES
177	* a limit of 1024 into their select. Where people have brains,	195	* a limit of 1024 into their select. Where people have brains,
178	* OS X engineers apparently have a vacuum. Or maybe they were	196	* OS X engineers apparently have a vacuum. Or maybe they were
…		…
326	# define EV_USE_PORT 0	344	# define EV_USE_PORT 0
327	#endif	345	#endif
328		346
329	#ifndef EV_USE_LINUXAIO	347	#ifndef EV_USE_LINUXAIO
330	# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */	348	# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */
331	# define EV_USE_LINUXAIO 1	349	# define EV_USE_LINUXAIO 0 /* was: 1, always off by default */
332	# else	350	# else
333	# define EV_USE_LINUXAIO 0	351	# define EV_USE_LINUXAIO 0
334	# endif	352	# endif
335	#endif	353	#endif
336		354
337	#ifndef EV_USE_IOURING	355	#ifndef EV_USE_IOURING
338	# if __linux	356	# if __linux /* later checks might disable again */
339	# define EV_USE_IOURING 0	357	# define EV_USE_IOURING 1
340	# else	358	# else
341	# define EV_USE_IOURING 0	359	# define EV_USE_IOURING 0
342	# endif	360	# endif
343	#endif	361	#endif
344		362
…		…
369	#ifndef EV_USE_SIGNALFD	387	#ifndef EV_USE_SIGNALFD
370	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))	388	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
371	# define EV_USE_SIGNALFD EV_FEATURE_OS	389	# define EV_USE_SIGNALFD EV_FEATURE_OS
372	# else	390	# else
373	# define EV_USE_SIGNALFD 0	391	# define EV_USE_SIGNALFD 0
		392	# endif
		393	#endif
		394
		395	#ifndef EV_USE_TIMERFD
		396	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8))
		397	# define EV_USE_TIMERFD EV_FEATURE_OS
		398	# else
		399	# define EV_USE_TIMERFD 0
374	# endif	400	# endif
375	#endif	401	#endif
376		402
377	#if 0 /* debugging */	403	#if 0 /* debugging */
378	# define EV_VERIFY 3	404	# define EV_VERIFY 3
…		…
438	#if !EV_STAT_ENABLE	464	#if !EV_STAT_ENABLE
439	# undef EV_USE_INOTIFY	465	# undef EV_USE_INOTIFY
440	# define EV_USE_INOTIFY 0	466	# define EV_USE_INOTIFY 0
441	#endif	467	#endif
442		468
		469	#if __linux && EV_USE_IOURING
		470	# include <linux/version.h>
		471	# if LINUX_VERSION_CODE < KERNEL_VERSION(4,14,0)
		472	# undef EV_USE_IOURING
		473	# define EV_USE_IOURING 0
		474	# endif
		475	#endif
		476
443	#if !EV_USE_NANOSLEEP	477	#if !EV_USE_NANOSLEEP
444	/* hp-ux has it in sys/time.h, which we unconditionally include above */	478	/* hp-ux has it in sys/time.h, which we unconditionally include above */
445	# if !defined _WIN32 && !defined __hpux	479	# if !defined _WIN32 && !defined __hpux
446	# include <sys/select.h>	480	# include <sys/select.h>
447	# endif	481	# endif
448	#endif	482	#endif
449		483
450	#if EV_USE_LINUXAIO	484	#if EV_USE_LINUXAIO
451	# include <sys/syscall.h>	485	# include <sys/syscall.h>
452	# if !SYS_io_getevents \|\| !EV_USE_EPOLL /* ev_linxaio uses ev_poll.c:ev_epoll_create */	486	# if SYS_io_getevents && EV_USE_EPOLL /* linuxaio backend requires epoll backend */
		487	# define EV_NEED_SYSCALL 1
		488	# else
453	# undef EV_USE_LINUXAIO	489	# undef EV_USE_LINUXAIO
454	# define EV_USE_LINUXAIO 0	490	# define EV_USE_LINUXAIO 0
455	# else
456	# define EV_NEED_SYSCALL 1
457	# endif	491	# endif
458	#endif	492	#endif
459		493
460	#if EV_USE_IOURING	494	#if EV_USE_IOURING
461	# include <sys/syscall.h>	495	# include <sys/syscall.h>
462	# if !__alpha && !SYS_io_uring_setup	496	# if !SYS_io_uring_setup && __linux && !__alpha
463	# define SYS_io_uring_setup 425	497	# define SYS_io_uring_setup 425
464	# define SYS_io_uring_enter 426	498	# define SYS_io_uring_enter 426
465	# define SYS_io_uring_wregister 427	499	# define SYS_io_uring_wregister 427
466	# endif	500	# endif
467	# if SYS_io_uring_setup	501	# if SYS_io_uring_setup && EV_USE_EPOLL /* iouring backend requires epoll backend */
468	# define EV_NEED_SYSCALL 1	502	# define EV_NEED_SYSCALL 1
469	# else	503	# else
470	# undef EV_USE_IOURING	504	# undef EV_USE_IOURING
471	# define EV_USE_IOURING 0	505	# define EV_USE_IOURING 0
472	# endif	506	# endif
…		…
481	# define EV_USE_INOTIFY 0	515	# define EV_USE_INOTIFY 0
482	# endif	516	# endif
483	#endif	517	#endif
484		518
485	#if EV_USE_EVENTFD	519	#if EV_USE_EVENTFD
486	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */	520	/* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
487	# include <stdint.h>	521	# include <stdint.h>
488	# ifndef EFD_NONBLOCK	522	# ifndef EFD_NONBLOCK
489	# define EFD_NONBLOCK O_NONBLOCK	523	# define EFD_NONBLOCK O_NONBLOCK
490	# endif	524	# endif
491	# ifndef EFD_CLOEXEC	525	# ifndef EFD_CLOEXEC
…		…
497	# endif	531	# endif
498	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);	532	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
499	#endif	533	#endif
500		534
501	#if EV_USE_SIGNALFD	535	#if EV_USE_SIGNALFD
502	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */	536	/* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
503	# include <stdint.h>	537	# include <stdint.h>
504	# ifndef SFD_NONBLOCK	538	# ifndef SFD_NONBLOCK
505	# define SFD_NONBLOCK O_NONBLOCK	539	# define SFD_NONBLOCK O_NONBLOCK
506	# endif	540	# endif
507	# ifndef SFD_CLOEXEC	541	# ifndef SFD_CLOEXEC
…		…
509	# define SFD_CLOEXEC O_CLOEXEC	543	# define SFD_CLOEXEC O_CLOEXEC
510	# else	544	# else
511	# define SFD_CLOEXEC 02000000	545	# define SFD_CLOEXEC 02000000
512	# endif	546	# endif
513	# endif	547	# endif
514	EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);	548	EV_CPP (extern "C") int (signalfd) (int fd, const sigset_t *mask, int flags);
515		549
516	struct signalfd_siginfo	550	struct signalfd_siginfo
517	{	551	{
518	uint32_t ssi_signo;	552	uint32_t ssi_signo;
519	char pad[128 - sizeof (uint32_t)];	553	char pad[128 - sizeof (uint32_t)];
520	};	554	};
521	#endif	555	#endif
522		556
523	/*****************************************************************************/	557	/* for timerfd, libev core requires TFD_TIMER_CANCEL_ON_SET &c */
524		558	#if EV_USE_TIMERFD
525	#if EV_NEED_SYSCALL	559	# include <sys/timerfd.h>
526		560	/* timerfd is only used for periodics */
527	#include <sys/syscall.h>	561	# if !(defined (TFD_TIMER_CANCEL_ON_SET) && defined (TFD_CLOEXEC) && defined (TFD_NONBLOCK)) \|\| !EV_PERIODIC_ENABLE
528		562	# undef EV_USE_TIMERFD
529	/*	563	# define EV_USE_TIMERFD 0
530	* define some syscall wrappers for common architectures
531	* this is mostly for nice looks during debugging, not performance.
532	* our syscalls return < 0, not == -1, on error. which is good
533	* enough for linux aio.
534	* TODO: arm is also common nowadays, maybe even mips and x86
535	* TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
536	*/
537	#if __GNUC__ && __linux && ECB_AMD64 && !defined __OPTIMIZE_SIZE__
538	/* the costly errno access probably kills this for size optimisation */
539
540	#define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5) \
541	({ \
542	long res; \
543	register unsigned long r5 __asm__ ("r8" ); \
544	register unsigned long r4 __asm__ ("r10"); \
545	register unsigned long r3 __asm__ ("rdx"); \
546	register unsigned long r2 __asm__ ("rsi"); \
547	register unsigned long r1 __asm__ ("rdi"); \
548	if (narg >= 5) r5 = (unsigned long)(arg5); \
549	if (narg >= 4) r4 = (unsigned long)(arg4); \
550	if (narg >= 3) r3 = (unsigned long)(arg3); \
551	if (narg >= 2) r2 = (unsigned long)(arg2); \
552	if (narg >= 1) r1 = (unsigned long)(arg1); \
553	__asm__ __volatile__ ( \
554	"syscall\n\t" \
555	: "=a" (res) \
556	: "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
557	: "cc", "r11", "cx", "memory"); \
558	errno = -res; \
559	res; \
560	})
561
562	#endif	564	# endif
563
564	#ifdef ev_syscall
565	#define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0
566	#define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0)
567	#define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0)
568	#define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0)
569	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0)
570	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5)
571	#else
572	#define ev_syscall0(nr) syscall (nr)
573	#define ev_syscall1(nr,arg1) syscall (nr, arg1)
574	#define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
575	#define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
576	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
577	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
578	#endif
579
580	#endif	565	#endif
581		566
582	/*****************************************************************************/	567	/*****************************************************************************/
583		568
584	#if EV_VERIFY >= 3	569	#if EV_VERIFY >= 3
…		…
592	* This value is good at least till the year 4000.	577	* This value is good at least till the year 4000.
593	*/	578	*/
594	#define MIN_INTERVAL 0.0001220703125 /* 1/2*13, good till 4000 /	579	#define MIN_INTERVAL 0.0001220703125 /* 1/2*13, good till 4000 /
595	/#define MIN_INTERVAL 0.00000095367431640625 / 1/2*20, good till 2200 /	580	/#define MIN_INTERVAL 0.00000095367431640625 / 1/2*20, good till 2200 /
596		581
597	#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) */
598	#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 */
599		585
		586	/* find a portable timestamp that is "always" in the future but fits into time_t.
		587	* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
		588	* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
		589	#define EV_TSTAMP_HUGE \
		590	(sizeof (time_t) >= 8 ? 10000000000000. \
		591	: 0 < (time_t)4294967295 ? 4294967295. \
		592	: 2147483647.) \
		593
		594	#ifndef EV_TS_CONST
		595	# define EV_TS_CONST(nv) nv
		596	# define EV_TS_TO_MSEC(a) a * 1e3 + 0.9999
		597	# define EV_TS_FROM_USEC(us) us * 1e-6
600	#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)	598	# define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
601	#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)	599	# define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
		600	# define EV_TV_GET(tv) ((tv).tv_sec + (tv).tv_usec * 1e-6)
		601	# define EV_TS_GET(ts) ((ts).tv_sec + (ts).tv_nsec * 1e-9)
		602	#endif
602		603
603	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */	604	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
604	/* ECB.H BEGIN */	605	/* ECB.H BEGIN */
605	/*	606	/*
606	* libecb - http://software.schmorp.de/pkg/libecb	607	* libecb - http://software.schmorp.de/pkg/libecb
607	*	608	*
608	* Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>	609	* Copyright (©) 2009-2015,2018-2020 Marc Alexander Lehmann <libecb@schmorp.de>
609	* Copyright (©) 2011 Emanuele Giaquinta	610	* Copyright (©) 2011 Emanuele Giaquinta
610	* All rights reserved.	611	* All rights reserved.
611	*	612	*
612	* Redistribution and use in source and binary forms, with or without modifica-	613	* Redistribution and use in source and binary forms, with or without modifica-
613	* tion, are permitted provided that the following conditions are met:	614	* tion, are permitted provided that the following conditions are met:
…		…
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
…		…
1643	# define inline_speed ecb_inline	1773	# define inline_speed ecb_inline
1644	#else	1774	#else
1645	# define inline_speed ecb_noinline static	1775	# define inline_speed ecb_noinline static
1646	#endif	1776	#endif
1647		1777
		1778	/*****************************************************************************/
		1779	/* raw syscall wrappers */
		1780
		1781	#if EV_NEED_SYSCALL
		1782
		1783	#include <sys/syscall.h>
		1784
		1785	/*
		1786	* define some syscall wrappers for common architectures
		1787	* this is mostly for nice looks during debugging, not performance.
		1788	* our syscalls return < 0, not == -1, on error. which is good
		1789	* enough for linux aio.
		1790	* TODO: arm is also common nowadays, maybe even mips and x86
		1791	* TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
		1792	*/
		1793	#if __GNUC__ && __linux && ECB_AMD64 && !EV_FEATURE_CODE
		1794	/* the costly errno access probably kills this for size optimisation */
		1795
		1796	#define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5,arg6) \
		1797	({ \
		1798	long res; \
		1799	register unsigned long r6 __asm__ ("r9" ); \
		1800	register unsigned long r5 __asm__ ("r8" ); \
		1801	register unsigned long r4 __asm__ ("r10"); \
		1802	register unsigned long r3 __asm__ ("rdx"); \
		1803	register unsigned long r2 __asm__ ("rsi"); \
		1804	register unsigned long r1 __asm__ ("rdi"); \
		1805	if (narg >= 6) r6 = (unsigned long)(arg6); \
		1806	if (narg >= 5) r5 = (unsigned long)(arg5); \
		1807	if (narg >= 4) r4 = (unsigned long)(arg4); \
		1808	if (narg >= 3) r3 = (unsigned long)(arg3); \
		1809	if (narg >= 2) r2 = (unsigned long)(arg2); \
		1810	if (narg >= 1) r1 = (unsigned long)(arg1); \
		1811	__asm__ __volatile__ ( \
		1812	"syscall\n\t" \
		1813	: "=a" (res) \
		1814	: "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
		1815	: "cc", "r11", "cx", "memory"); \
		1816	errno = -res; \
		1817	res; \
		1818	})
		1819
		1820	#endif
		1821
		1822	#ifdef ev_syscall
		1823	#define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0, 0)
		1824	#define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0, 0)
		1825	#define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0, 0)
		1826	#define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0, 0)
		1827	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0, 0)
		1828	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5, 0)
		1829	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) ev_syscall (nr, 6, arg1, arg2, arg3, arg4, arg5,arg6)
		1830	#else
		1831	#define ev_syscall0(nr) syscall (nr)
		1832	#define ev_syscall1(nr,arg1) syscall (nr, arg1)
		1833	#define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
		1834	#define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
		1835	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
		1836	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
		1837	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) syscall (nr, arg1, arg2, arg3, arg4, arg5,arg6)
		1838	#endif
		1839
		1840	#endif
		1841
		1842	/*****************************************************************************/
		1843
1648	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1844	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1649		1845
1650	#if EV_MINPRI == EV_MAXPRI	1846	#if EV_MINPRI == EV_MAXPRI
1651	# define ABSPRI(w) (((W)w), 0)	1847	# define ABSPRI(w) (((W)w), 0)
1652	#else	1848	#else
…		…
1711	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1907	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1712	#else	1908	#else
1713	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1909	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1714	#endif	1910	#endif
1715		1911
		1912	/* special treatment for negative arguments */
		1913	if (ecb_expect_false (v < 0.))
		1914	{
		1915	ev_tstamp f = -ev_floor (-v);
		1916
		1917	return f - (f == v ? 0 : 1);
		1918	}
		1919
1716	/* argument too large for an unsigned long? */	1920	/* argument too large for an unsigned long? then reduce it */
1717	if (ecb_expect_false (v >= shift))	1921	if (ecb_expect_false (v >= shift))
1718	{	1922	{
1719	ev_tstamp f;	1923	ev_tstamp f;
1720		1924
1721	if (v == v - 1.)	1925	if (v == v - 1.)
1722	return v; /* very large number */	1926	return v; /* very large numbers are assumed to be integer */
1723		1927
1724	f = shift * ev_floor (v * (1. / shift));	1928	f = shift * ev_floor (v * (1. / shift));
1725	return f + ev_floor (v - f);	1929	return f + ev_floor (v - f);
1726	}
1727
1728	/* special treatment for negative args? */
1729	if (ecb_expect_false (v < 0.))
1730	{
1731	ev_tstamp f = -ev_floor (-v);
1732
1733	return f - (f == v ? 0 : 1);
1734	}	1930	}
1735		1931
1736	/* fits into an unsigned long */	1932	/* fits into an unsigned long */
1737	return (unsigned long)v;	1933	return (unsigned long)v;
1738	}	1934	}
…		…
1882	{	2078	{
1883	WL head;	2079	WL head;
1884	unsigned char events; /* the events watched for */	2080	unsigned char events; /* the events watched for */
1885	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */	2081	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
1886	unsigned char emask; /* some backends store the actual kernel mask in here */	2082	unsigned char emask; /* some backends store the actual kernel mask in here */
1887	unsigned char unused;	2083	unsigned char eflags; /* flags field for use by backends */
1888	#if EV_USE_EPOLL	2084	#if EV_USE_EPOLL
1889	unsigned int egen; /* generation counter to counter epoll bugs */	2085	unsigned int egen; /* generation counter to counter epoll bugs */
1890	#endif	2086	#endif
1891	#if EV_SELECT_IS_WINSOCKET \|\| EV_USE_IOCP	2087	#if EV_SELECT_IS_WINSOCKET \|\| EV_USE_IOCP
1892	SOCKET handle;	2088	SOCKET handle;
…		…
1946	static struct ev_loop default_loop_struct;	2142	static struct ev_loop default_loop_struct;
1947	EV_API_DECL struct ev_loop ev_default_loop_ptr = 0; / needs to be initialised to make it a definition despite extern */	2143	EV_API_DECL struct ev_loop ev_default_loop_ptr = 0; / needs to be initialised to make it a definition despite extern */
1948		2144
1949	#else	2145	#else
1950		2146
1951	EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */	2147	EV_API_DECL ev_tstamp ev_rt_now = EV_TS_CONST (0.); /* needs to be initialised to make it a definition despite extern */
1952	#define VAR(name,decl) static decl;	2148	#define VAR(name,decl) static decl;
1953	#include "ev_vars.h"	2149	#include "ev_vars.h"
1954	#undef VAR	2150	#undef VAR
1955		2151
1956	static int ev_default_loop_ptr;	2152	static int ev_default_loop_ptr;
…		…
1978	#if EV_USE_REALTIME	2174	#if EV_USE_REALTIME
1979	if (ecb_expect_true (have_realtime))	2175	if (ecb_expect_true (have_realtime))
1980	{	2176	{
1981	struct timespec ts;	2177	struct timespec ts;
1982	clock_gettime (CLOCK_REALTIME, &ts);	2178	clock_gettime (CLOCK_REALTIME, &ts);
1983	return ts.tv_sec + ts.tv_nsec * 1e-9;	2179	return EV_TS_GET (ts);
1984	}	2180	}
1985	#endif	2181	#endif
1986		2182
		2183	{
1987	struct timeval tv;	2184	struct timeval tv;
1988	gettimeofday (&tv, 0);	2185	gettimeofday (&tv, 0);
1989	return tv.tv_sec + tv.tv_usec * 1e-6;	2186	return EV_TV_GET (tv);
		2187	}
1990	}	2188	}
1991	#endif	2189	#endif
1992		2190
1993	inline_size ev_tstamp	2191	inline_size ev_tstamp
1994	get_clock (void)	2192	get_clock (void)
…		…
1996	#if EV_USE_MONOTONIC	2194	#if EV_USE_MONOTONIC
1997	if (ecb_expect_true (have_monotonic))	2195	if (ecb_expect_true (have_monotonic))
1998	{	2196	{
1999	struct timespec ts;	2197	struct timespec ts;
2000	clock_gettime (CLOCK_MONOTONIC, &ts);	2198	clock_gettime (CLOCK_MONOTONIC, &ts);
2001	return ts.tv_sec + ts.tv_nsec * 1e-9;	2199	return EV_TS_GET (ts);
2002	}	2200	}
2003	#endif	2201	#endif
2004		2202
2005	return ev_time ();	2203	return ev_time ();
2006	}	2204	}
…		…
2014	#endif	2212	#endif
2015		2213
2016	void	2214	void
2017	ev_sleep (ev_tstamp delay) EV_NOEXCEPT	2215	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
2018	{	2216	{
2019	if (delay > 0.)	2217	if (delay > EV_TS_CONST (0.))
2020	{	2218	{
2021	#if EV_USE_NANOSLEEP	2219	#if EV_USE_NANOSLEEP
2022	struct timespec ts;	2220	struct timespec ts;
2023		2221
2024	EV_TS_SET (ts, delay);	2222	EV_TS_SET (ts, delay);
2025	nanosleep (&ts, 0);	2223	nanosleep (&ts, 0);
2026	#elif defined _WIN32	2224	#elif defined _WIN32
2027	/* maybe this should round up, as ms is very low resolution */	2225	/* maybe this should round up, as ms is very low resolution */
2028	/* compared to select (µs) or nanosleep (ns) */	2226	/* compared to select (µs) or nanosleep (ns) */
2029	Sleep ((unsigned long)(delay * 1e3));	2227	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
2030	#else	2228	#else
2031	struct timeval tv;	2229	struct timeval tv;
2032		2230
2033	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */	2231	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
2034	/* something not guaranteed by newer posix versions, but guaranteed */	2232	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
2194	inline_size void	2392	inline_size void
2195	fd_reify (EV_P)	2393	fd_reify (EV_P)
2196	{	2394	{
2197	int i;	2395	int i;
2198		2396
		2397	/* most backends do not modify the fdchanges list in backend_modfiy.
		2398	* except io_uring, which has fixed-size buffers which might force us
		2399	* to handle events in backend_modify, causing fdchanges to be amended,
		2400	* which could result in an endless loop.
		2401	* to avoid this, we do not dynamically handle fds that were added
		2402	* during fd_reify. that means that for those backends, fdchangecnt
		2403	* might be non-zero during poll, which must cause them to not block.
		2404	* to not put too much of a burden on other backends, this detail
		2405	* needs to be handled in the backend.
		2406	*/
		2407	int changecnt = fdchangecnt;
		2408
2199	#if EV_SELECT_IS_WINSOCKET \|\| EV_USE_IOCP	2409	#if EV_SELECT_IS_WINSOCKET \|\| EV_USE_IOCP
2200	for (i = 0; i < fdchangecnt; ++i)	2410	for (i = 0; i < changecnt; ++i)
2201	{	2411	{
2202	int fd = fdchanges [i];	2412	int fd = fdchanges [i];
2203	ANFD *anfd = anfds + fd;	2413	ANFD *anfd = anfds + fd;
2204		2414
2205	if (anfd->reify & EV__IOFDSET && anfd->head)	2415	if (anfd->reify & EV__IOFDSET && anfd->head)
…		…
2219	}	2429	}
2220	}	2430	}
2221	}	2431	}
2222	#endif	2432	#endif
2223		2433
2224	for (i = 0; i < fdchangecnt; ++i)	2434	for (i = 0; i < changecnt; ++i)
2225	{	2435	{
2226	int fd = fdchanges [i];	2436	int fd = fdchanges [i];
2227	ANFD *anfd = anfds + fd;	2437	ANFD *anfd = anfds + fd;
2228	ev_io *w;	2438	ev_io *w;
2229		2439
…		…
2245		2455
2246	if (o_reify & EV__IOFDSET)	2456	if (o_reify & EV__IOFDSET)
2247	backend_modify (EV_A_ fd, o_events, anfd->events);	2457	backend_modify (EV_A_ fd, o_events, anfd->events);
2248	}	2458	}
2249		2459
		2460	/* normally, fdchangecnt hasn't changed. if it has, then new fds have been added.
		2461	* this is a rare case (see beginning comment in this function), so we copy them to the
		2462	* front and hope the backend handles this case.
		2463	*/
		2464	if (ecb_expect_false (fdchangecnt != changecnt))
		2465	memmove (fdchanges, fdchanges + changecnt, (fdchangecnt - changecnt) * sizeof (*fdchanges));
		2466
2250	fdchangecnt = 0;	2467	fdchangecnt -= changecnt;
2251	}	2468	}
2252		2469
2253	/* something about the given fd changed */	2470	/* something about the given fd changed */
2254	inline_size	2471	inline_size
2255	void	2472	void
…		…
2384		2601
2385	/* find minimum child */	2602	/* find minimum child */
2386	if (ecb_expect_true (pos + DHEAP - 1 < E))	2603	if (ecb_expect_true (pos + DHEAP - 1 < E))
2387	{	2604	{
2388	/* fast path / (minpos = pos + 0), (minat = ANHE_at (minpos));	2605	/* fast path / (minpos = pos + 0), (minat = ANHE_at (minpos));
2389	if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2606	if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2390	if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2607	if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2391	if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2608	if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2392	}	2609	}
2393	else if (pos < E)	2610	else if (pos < E)
2394	{	2611	{
2395	/* slow path / (minpos = pos + 0), (minat = ANHE_at (minpos));	2612	/* slow path / (minpos = pos + 0), (minat = ANHE_at (minpos));
2396	if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2613	if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2397	if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2614	if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2398	if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2615	if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2399	}	2616	}
2400	else	2617	else
2401	break;	2618	break;
2402		2619
2403	if (ANHE_at (he) <= minat)	2620	if (ANHE_at (he) <= minat)
…		…
2411		2628
2412	heap [k] = he;	2629	heap [k] = he;
2413	ev_active (ANHE_w (he)) = k;	2630	ev_active (ANHE_w (he)) = k;
2414	}	2631	}
2415		2632
2416	#else /* 4HEAP */	2633	#else /* not 4HEAP */
2417		2634
2418	#define HEAP0 1	2635	#define HEAP0 1
2419	#define HPARENT(k) ((k) >> 1)	2636	#define HPARENT(k) ((k) >> 1)
2420	#define UPHEAP_DONE(p,k) (!(p))	2637	#define UPHEAP_DONE(p,k) (!(p))
2421		2638
…		…
2493	upheap (heap, i + HEAP0);	2710	upheap (heap, i + HEAP0);
2494	}	2711	}
2495		2712
2496	/*****************************************************************************/	2713	/*****************************************************************************/
2497		2714
2498	/* associate signal watchers to a signal signal */	2715	/* associate signal watchers to a signal */
2499	typedef struct	2716	typedef struct
2500	{	2717	{
2501	EV_ATOMIC_T pending;	2718	EV_ATOMIC_T pending;
2502	#if EV_MULTIPLICITY	2719	#if EV_MULTIPLICITY
2503	EV_P;	2720	EV_P;
…		…
2807		3024
2808	#endif	3025	#endif
2809		3026
2810	/*****************************************************************************/	3027	/*****************************************************************************/
2811		3028
		3029	#if EV_USE_TIMERFD
		3030
		3031	static void periodics_reschedule (EV_P);
		3032
		3033	static void
		3034	timerfdcb (EV_P_ ev_io *iow, int revents)
		3035	{
		3036	struct itimerspec its = { 0 };
		3037
		3038	its.it_value.tv_sec = ev_rt_now + (int)MAX_BLOCKTIME2;
		3039	timerfd_settime (timerfd, TFD_TIMER_ABSTIME \| TFD_TIMER_CANCEL_ON_SET, &its, 0);
		3040
		3041	ev_rt_now = ev_time ();
		3042	/* periodics_reschedule only needs ev_rt_now */
		3043	/* but maybe in the future we want the full treatment. */
		3044	/*
		3045	now_floor = EV_TS_CONST (0.);
		3046	time_update (EV_A_ EV_TSTAMP_HUGE);
		3047	*/
		3048	#if EV_PERIODIC_ENABLE
		3049	periodics_reschedule (EV_A);
		3050	#endif
		3051	}
		3052
		3053	ecb_noinline ecb_cold
		3054	static void
		3055	evtimerfd_init (EV_P)
		3056	{
		3057	if (!ev_is_active (&timerfd_w))
		3058	{
		3059	timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK \| TFD_CLOEXEC);
		3060
		3061	if (timerfd >= 0)
		3062	{
		3063	fd_intern (timerfd); /* just to be sure */
		3064
		3065	ev_io_init (&timerfd_w, timerfdcb, timerfd, EV_READ);
		3066	ev_set_priority (&timerfd_w, EV_MINPRI);
		3067	ev_io_start (EV_A_ &timerfd_w);
		3068	ev_unref (EV_A); /* watcher should not keep loop alive */
		3069
		3070	/* (re-) arm timer */
		3071	timerfdcb (EV_A_ 0, 0);
		3072	}
		3073	}
		3074	}
		3075
		3076	#endif
		3077
		3078	/*****************************************************************************/
		3079
2812	#if EV_USE_IOCP	3080	#if EV_USE_IOCP
2813	# include "ev_iocp.c"	3081	# include "ev_iocp.c"
2814	#endif	3082	#endif
2815	#if EV_USE_PORT	3083	#if EV_USE_PORT
2816	# include "ev_port.c"	3084	# include "ev_port.c"
…		…
2862	unsigned int	3130	unsigned int
2863	ev_supported_backends (void) EV_NOEXCEPT	3131	ev_supported_backends (void) EV_NOEXCEPT
2864	{	3132	{
2865	unsigned int flags = 0;	3133	unsigned int flags = 0;
2866		3134
2867	if (EV_USE_PORT ) flags \|= EVBACKEND_PORT;	3135	if (EV_USE_PORT ) flags \|= EVBACKEND_PORT;
2868	if (EV_USE_KQUEUE ) flags \|= EVBACKEND_KQUEUE;	3136	if (EV_USE_KQUEUE ) flags \|= EVBACKEND_KQUEUE;
2869	if (EV_USE_EPOLL ) flags \|= EVBACKEND_EPOLL;	3137	if (EV_USE_EPOLL ) flags \|= EVBACKEND_EPOLL;
2870	if (EV_USE_LINUXAIO) flags \|= EVBACKEND_LINUXAIO;	3138	if (EV_USE_LINUXAIO ) flags \|= EVBACKEND_LINUXAIO;
2871	if (EV_USE_IOURING ) flags \|= EVBACKEND_IOURING;	3139	if (EV_USE_IOURING && ev_linux_version () >= 0x050601) flags \|= EVBACKEND_IOURING; /* 5.6.1+ */
2872	if (EV_USE_POLL ) flags \|= EVBACKEND_POLL;	3140	if (EV_USE_POLL ) flags \|= EVBACKEND_POLL;
2873	if (EV_USE_SELECT ) flags \|= EVBACKEND_SELECT;	3141	if (EV_USE_SELECT ) flags \|= EVBACKEND_SELECT;
2874		3142
2875	return flags;	3143	return flags;
2876	}	3144	}
2877		3145
2878	ecb_cold	3146	ecb_cold
2879	unsigned int	3147	unsigned int
…		…
2909		3177
2910	ecb_cold	3178	ecb_cold
2911	unsigned int	3179	unsigned int
2912	ev_embeddable_backends (void) EV_NOEXCEPT	3180	ev_embeddable_backends (void) EV_NOEXCEPT
2913	{	3181	{
2914	int flags = EVBACKEND_EPOLL \| EVBACKEND_KQUEUE \| EVBACKEND_PORT;	3182	int flags = EVBACKEND_EPOLL \| EVBACKEND_KQUEUE \| EVBACKEND_PORT \| EVBACKEND_IOURING;
2915		3183
2916	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	3184	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2917	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	3185	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2918	flags &= ~EVBACKEND_EPOLL;	3186	flags &= ~EVBACKEND_EPOLL;
		3187
		3188	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
2919		3189
2920	return flags;	3190	return flags;
2921	}	3191	}
2922		3192
2923	unsigned int	3193	unsigned int
…		…
3041	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3311	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
3042	#endif	3312	#endif
3043	#if EV_USE_SIGNALFD	3313	#if EV_USE_SIGNALFD
3044	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3314	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
3045	#endif	3315	#endif
		3316	#if EV_USE_TIMERFD
		3317	timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
		3318	#endif
3046		3319
3047	if (!(flags & EVBACKEND_MASK))	3320	if (!(flags & EVBACKEND_MASK))
3048	flags \|= ev_recommended_backends ();	3321	flags \|= ev_recommended_backends ();
3049		3322
3050	#if EV_USE_IOCP	3323	#if EV_USE_IOCP
…		…
3121	}	3394	}
3122		3395
3123	#if EV_USE_SIGNALFD	3396	#if EV_USE_SIGNALFD
3124	if (ev_is_active (&sigfd_w))	3397	if (ev_is_active (&sigfd_w))
3125	close (sigfd);	3398	close (sigfd);
		3399	#endif
		3400
		3401	#if EV_USE_TIMERFD
		3402	if (ev_is_active (&timerfd_w))
		3403	close (timerfd);
3126	#endif	3404	#endif
3127		3405
3128	#if EV_USE_INOTIFY	3406	#if EV_USE_INOTIFY
3129	if (fs_fd >= 0)	3407	if (fs_fd >= 0)
3130	close (fs_fd);	3408	close (fs_fd);
…		…
3223	#endif	3501	#endif
3224	#if EV_USE_INOTIFY	3502	#if EV_USE_INOTIFY
3225	infy_fork (EV_A);	3503	infy_fork (EV_A);
3226	#endif	3504	#endif
3227		3505
		3506	if (postfork != 2)
		3507	{
		3508	#if EV_USE_SIGNALFD
		3509	/* surprisingly, nothing needs to be done for signalfd, accoridng to docs, it does the right thing on fork */
		3510	#endif
		3511
		3512	#if EV_USE_TIMERFD
		3513	if (ev_is_active (&timerfd_w))
		3514	{
		3515	ev_ref (EV_A);
		3516	ev_io_stop (EV_A_ &timerfd_w);
		3517
		3518	close (timerfd);
		3519	timerfd = -2;
		3520
		3521	evtimerfd_init (EV_A);
		3522	/* reschedule periodics, in case we missed something */
		3523	ev_feed_event (EV_A_ &timerfd_w, EV_CUSTOM);
		3524	}
		3525	#endif
		3526
3228	#if EV_SIGNAL_ENABLE \|\| EV_ASYNC_ENABLE	3527	#if EV_SIGNAL_ENABLE \|\| EV_ASYNC_ENABLE
3229	if (ev_is_active (&pipe_w) && postfork != 2)	3528	if (ev_is_active (&pipe_w))
3230	{	3529	{
3231	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3530	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
3232		3531
3233	ev_ref (EV_A);	3532	ev_ref (EV_A);
3234	ev_io_stop (EV_A_ &pipe_w);	3533	ev_io_stop (EV_A_ &pipe_w);
3235		3534
3236	if (evpipe [0] >= 0)	3535	if (evpipe [0] >= 0)
3237	EV_WIN32_CLOSE_FD (evpipe [0]);	3536	EV_WIN32_CLOSE_FD (evpipe [0]);
3238		3537
3239	evpipe_init (EV_A);	3538	evpipe_init (EV_A);
3240	/* iterate over everything, in case we missed something before */	3539	/* iterate over everything, in case we missed something before */
3241	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3540	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
		3541	}
		3542	#endif
3242	}	3543	}
3243	#endif
3244		3544
3245	postfork = 0;	3545	postfork = 0;
3246	}	3546	}
3247		3547
3248	#if EV_MULTIPLICITY	3548	#if EV_MULTIPLICITY
…		…
3518	{	3818	{
3519	ev_at (w) += w->repeat;	3819	ev_at (w) += w->repeat;
3520	if (ev_at (w) < mn_now)	3820	if (ev_at (w) < mn_now)
3521	ev_at (w) = mn_now;	3821	ev_at (w) = mn_now;
3522		3822
3523	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));	3823	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > EV_TS_CONST (0.)));
3524		3824
3525	ANHE_at_cache (timers [HEAP0]);	3825	ANHE_at_cache (timers [HEAP0]);
3526	downheap (timers, timercnt, HEAP0);	3826	downheap (timers, timercnt, HEAP0);
3527	}	3827	}
3528	else	3828	else
…		…
3659		3959
3660	mn_now = get_clock ();	3960	mn_now = get_clock ();
3661		3961
3662	/* only fetch the realtime clock every 0.5MIN_TIMEJUMP seconds /	3962	/* only fetch the realtime clock every 0.5MIN_TIMEJUMP seconds /
3663	/* interpolate in the meantime */	3963	/* interpolate in the meantime */
3664	if (ecb_expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))	3964	if (ecb_expect_true (mn_now - now_floor < EV_TS_CONST (MIN_TIMEJUMP * .5)))
3665	{	3965	{
3666	ev_rt_now = rtmn_diff + mn_now;	3966	ev_rt_now = rtmn_diff + mn_now;
3667	return;	3967	return;
3668	}	3968	}
3669		3969
…		…
3683	ev_tstamp diff;	3983	ev_tstamp diff;
3684	rtmn_diff = ev_rt_now - mn_now;	3984	rtmn_diff = ev_rt_now - mn_now;
3685		3985
3686	diff = odiff - rtmn_diff;	3986	diff = odiff - rtmn_diff;
3687		3987
3688	if (ecb_expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))	3988	if (ecb_expect_true ((diff < EV_TS_CONST (0.) ? -diff : diff) < EV_TS_CONST (MIN_TIMEJUMP)))
3689	return; /* all is well */	3989	return; /* all is well */
3690		3990
3691	ev_rt_now = ev_time ();	3991	ev_rt_now = ev_time ();
3692	mn_now = get_clock ();	3992	mn_now = get_clock ();
3693	now_floor = mn_now;	3993	now_floor = mn_now;
…		…
3702	else	4002	else
3703	#endif	4003	#endif
3704	{	4004	{
3705	ev_rt_now = ev_time ();	4005	ev_rt_now = ev_time ();
3706		4006
3707	if (ecb_expect_false (mn_now > ev_rt_now \|\| ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))	4007	if (ecb_expect_false (mn_now > ev_rt_now \|\| ev_rt_now > mn_now + max_block + EV_TS_CONST (MIN_TIMEJUMP)))
3708	{	4008	{
3709	/* adjust timers. this is easy, as the offset is the same for all of them */	4009	/* adjust timers. this is easy, as the offset is the same for all of them */
3710	timers_reschedule (EV_A_ ev_rt_now - mn_now);	4010	timers_reschedule (EV_A_ ev_rt_now - mn_now);
3711	#if EV_PERIODIC_ENABLE	4011	#if EV_PERIODIC_ENABLE
3712	periodics_reschedule (EV_A);	4012	periodics_reschedule (EV_A);
…		…
3781		4081
3782	/* remember old timestamp for io_blocktime calculation */	4082	/* remember old timestamp for io_blocktime calculation */
3783	ev_tstamp prev_mn_now = mn_now;	4083	ev_tstamp prev_mn_now = mn_now;
3784		4084
3785	/* update time to cancel out callback processing overhead */	4085	/* update time to cancel out callback processing overhead */
3786	time_update (EV_A_ 1e100);	4086	time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
3787		4087
3788	/* from now on, we want a pipe-wake-up */	4088	/* from now on, we want a pipe-wake-up */
3789	pipe_write_wanted = 1;	4089	pipe_write_wanted = 1;
3790		4090
3791	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */	4091	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3792		4092
3793	if (ecb_expect_true (!(flags & EVRUN_NOWAIT \|\| idleall \|\| !activecnt \|\| pipe_write_skipped)))	4093	if (ecb_expect_true (!(flags & EVRUN_NOWAIT \|\| idleall \|\| !activecnt \|\| pipe_write_skipped)))
3794	{	4094	{
3795	waittime = MAX_BLOCKTIME;	4095	waittime = EV_TS_CONST (MAX_BLOCKTIME);
		4096
		4097	#if EV_USE_TIMERFD
		4098	/* sleep a lot longer when we can reliably detect timejumps */
		4099	if (ecb_expect_true (timerfd >= 0))
		4100	waittime = EV_TS_CONST (MAX_BLOCKTIME2);
		4101	#endif
		4102	#if !EV_PERIODIC_ENABLE
		4103	/* without periodics but with monotonic clock there is no need */
		4104	/* for any time jump detection, so sleep longer */
		4105	if (ecb_expect_true (have_monotonic))
		4106	waittime = EV_TS_CONST (MAX_BLOCKTIME2);
		4107	#endif
3796		4108
3797	if (timercnt)	4109	if (timercnt)
3798	{	4110	{
3799	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	4111	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3800	if (waittime > to) waittime = to;	4112	if (waittime > to) waittime = to;
…		…
3810		4122
3811	/* don't let timeouts decrease the waittime below timeout_blocktime */	4123	/* don't let timeouts decrease the waittime below timeout_blocktime */
3812	if (ecb_expect_false (waittime < timeout_blocktime))	4124	if (ecb_expect_false (waittime < timeout_blocktime))
3813	waittime = timeout_blocktime;	4125	waittime = timeout_blocktime;
3814		4126
3815	/* at this point, we NEED to wait, so we have to ensure */	4127	/* now there are two more special cases left, either we have
3816	/* to pass a minimum nonzero value to the backend */	4128	* already-expired timers, so we should not sleep, or we have timers
		4129	* that expire very soon, in which case we need to wait for a minimum
		4130	* amount of time for some event loop backends.
		4131	*/
3817	if (ecb_expect_false (waittime < backend_mintime))	4132	if (ecb_expect_false (waittime < backend_mintime))
		4133	waittime = waittime <= EV_TS_CONST (0.)
		4134	? EV_TS_CONST (0.)
3818	waittime = backend_mintime;	4135	: backend_mintime;
3819		4136
3820	/* extra check because io_blocktime is commonly 0 */	4137	/* extra check because io_blocktime is commonly 0 */
3821	if (ecb_expect_false (io_blocktime))	4138	if (ecb_expect_false (io_blocktime))
3822	{	4139	{
3823	sleeptime = io_blocktime - (mn_now - prev_mn_now);	4140	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3824		4141
3825	if (sleeptime > waittime - backend_mintime)	4142	if (sleeptime > waittime - backend_mintime)
3826	sleeptime = waittime - backend_mintime;	4143	sleeptime = waittime - backend_mintime;
3827		4144
3828	if (ecb_expect_true (sleeptime > 0.))	4145	if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
3829	{	4146	{
3830	ev_sleep (sleeptime);	4147	ev_sleep (sleeptime);
3831	waittime -= sleeptime;	4148	waittime -= sleeptime;
3832	}	4149	}
3833	}	4150	}
…		…
3907	}	4224	}
3908		4225
3909	void	4226	void
3910	ev_now_update (EV_P) EV_NOEXCEPT	4227	ev_now_update (EV_P) EV_NOEXCEPT
3911	{	4228	{
3912	time_update (EV_A_ 1e100);	4229	time_update (EV_A_ EV_TSTAMP_HUGE);
3913	}	4230	}
3914		4231
3915	void	4232	void
3916	ev_suspend (EV_P) EV_NOEXCEPT	4233	ev_suspend (EV_P) EV_NOEXCEPT
3917	{	4234	{
…		…
4148	}	4465	}
4149		4466
4150	ev_tstamp	4467	ev_tstamp
4151	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT	4468	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
4152	{	4469	{
4153	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4470	return ev_at (w) - (ev_is_active (w) ? mn_now : EV_TS_CONST (0.));
4154	}	4471	}
4155		4472
4156	#if EV_PERIODIC_ENABLE	4473	#if EV_PERIODIC_ENABLE
4157	ecb_noinline	4474	ecb_noinline
4158	void	4475	void
4159	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT	4476	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4160	{	4477	{
4161	if (ecb_expect_false (ev_is_active (w)))	4478	if (ecb_expect_false (ev_is_active (w)))
4162	return;	4479	return;
		4480
		4481	#if EV_USE_TIMERFD
		4482	if (timerfd == -2)
		4483	evtimerfd_init (EV_A);
		4484	#endif
4163		4485
4164	if (w->reschedule_cb)	4486	if (w->reschedule_cb)
4165	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4487	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
4166	else if (w->interval)	4488	else if (w->interval)
4167	{	4489	{
…		…
4909	ev_run (EV_A_ EVRUN_NOWAIT);	5231	ev_run (EV_A_ EVRUN_NOWAIT);
4910	}	5232	}
4911	}	5233	}
4912	}	5234	}
4913		5235
		5236	#if EV_FORK_ENABLE
4914	static void	5237	static void
4915	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)	5238	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4916	{	5239	{
4917	ev_embed w = (ev_embed )(((char *)fork_w) - offsetof (ev_embed, fork));	5240	ev_embed w = (ev_embed )(((char *)fork_w) - offsetof (ev_embed, fork));
4918		5241
…		…
4925	ev_run (EV_A_ EVRUN_NOWAIT);	5248	ev_run (EV_A_ EVRUN_NOWAIT);
4926	}	5249	}
4927		5250
4928	ev_embed_start (EV_A_ w);	5251	ev_embed_start (EV_A_ w);
4929	}	5252	}
		5253	#endif
4930		5254
4931	#if 0	5255	#if 0
4932	static void	5256	static void
4933	embed_idle_cb (EV_P_ ev_idle *idle, int revents)	5257	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4934	{	5258	{
…		…
4955		5279
4956	ev_prepare_init (&w->prepare, embed_prepare_cb);	5280	ev_prepare_init (&w->prepare, embed_prepare_cb);
4957	ev_set_priority (&w->prepare, EV_MINPRI);	5281	ev_set_priority (&w->prepare, EV_MINPRI);
4958	ev_prepare_start (EV_A_ &w->prepare);	5282	ev_prepare_start (EV_A_ &w->prepare);
4959		5283
		5284	#if EV_FORK_ENABLE
4960	ev_fork_init (&w->fork, embed_fork_cb);	5285	ev_fork_init (&w->fork, embed_fork_cb);
4961	ev_fork_start (EV_A_ &w->fork);	5286	ev_fork_start (EV_A_ &w->fork);
		5287	#endif
4962		5288
4963	/ev_idle_init (&w->idle, e,bed_idle_cb);/	5289	/ev_idle_init (&w->idle, e,bed_idle_cb);/
4964		5290
4965	ev_start (EV_A_ (W)w, 1);	5291	ev_start (EV_A_ (W)w, 1);
4966		5292
…		…
4976		5302
4977	EV_FREQUENT_CHECK;	5303	EV_FREQUENT_CHECK;
4978		5304
4979	ev_io_stop (EV_A_ &w->io);	5305	ev_io_stop (EV_A_ &w->io);
4980	ev_prepare_stop (EV_A_ &w->prepare);	5306	ev_prepare_stop (EV_A_ &w->prepare);
		5307	#if EV_FORK_ENABLE
4981	ev_fork_stop (EV_A_ &w->fork);	5308	ev_fork_stop (EV_A_ &w->fork);
		5309	#endif
4982		5310
4983	ev_stop (EV_A_ (W)w);	5311	ev_stop (EV_A_ (W)w);
4984		5312
4985	EV_FREQUENT_CHECK;	5313	EV_FREQUENT_CHECK;
4986	}	5314	}

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.501 by root, Mon Jul 1 21:47:42 2019 UTC vs. Revision 1.526 by root, Wed Jan 22 17:11:33 2020 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.501 by root, Mon Jul 1 21:47:42 2019 UTC vs.
Revision 1.526 by root, Wed Jan 22 17:11:33 2020 UTC