ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.430 by root, Wed May 9 16:50:23 2012 UTC vs.
Revision 1.508 by root, Thu Jul 11 08:29:08 2019 UTC

1	/*	1	/*
2	* libev event processing core, watcher management	2	* libev event processing core, watcher management
3	*	3	*
4	* Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>	4	* Copyright (c) 2007-2019 Marc Alexander Lehmann <libev@schmorp.de>
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without modifica-	7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:	8	* tion, are permitted provided that the following conditions are met:
9	*	9	*
…		…
43	# include EV_CONFIG_H	43	# include EV_CONFIG_H
44	# else	44	# else
45	# include "config.h"	45	# include "config.h"
46	# endif	46	# endif
47		47
48	#if HAVE_FLOOR	48	# if HAVE_FLOOR
49	# ifndef EV_USE_FLOOR	49	# ifndef EV_USE_FLOOR
50	# define EV_USE_FLOOR 1	50	# define EV_USE_FLOOR 1
		51	# endif
51	# endif	52	# endif
52	#endif
53		53
54	# if HAVE_CLOCK_SYSCALL	54	# if HAVE_CLOCK_SYSCALL
55	# ifndef EV_USE_CLOCK_SYSCALL	55	# ifndef EV_USE_CLOCK_SYSCALL
56	# define EV_USE_CLOCK_SYSCALL 1	56	# define EV_USE_CLOCK_SYSCALL 1
57	# ifndef EV_USE_REALTIME	57	# ifndef EV_USE_REALTIME
…		…
113	# define EV_USE_EPOLL EV_FEATURE_BACKENDS	113	# define EV_USE_EPOLL EV_FEATURE_BACKENDS
114	# endif	114	# endif
115	# else	115	# else
116	# undef EV_USE_EPOLL	116	# undef EV_USE_EPOLL
117	# define EV_USE_EPOLL 0	117	# define EV_USE_EPOLL 0
		118	# endif
		119
		120	# if HAVE_LINUX_AIO_ABI_H
		121	# ifndef EV_USE_LINUXAIO
		122	# define EV_USE_LINUXAIO EV_FEATURE_BACKENDS
		123	# endif
		124	# else
		125	# undef EV_USE_LINUXAIO
		126	# define EV_USE_LINUXAIO 0
118	# endif	127	# endif
119		128
120	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H	129	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
121	# ifndef EV_USE_KQUEUE	130	# ifndef EV_USE_KQUEUE
122	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS	131	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS
…		…
162	# define EV_USE_EVENTFD 0	171	# define EV_USE_EVENTFD 0
163	# endif	172	# endif
164		173
165	#endif	174	#endif
166		175
		176	/* OS X, in its infinite idiocy, actually HARDCODES
		177	* a limit of 1024 into their select. Where people have brains,
		178	* OS X engineers apparently have a vacuum. Or maybe they were
		179	* ordered to have a vacuum, or they do anything for money.
		180	* This might help. Or not.
		181	* Note that this must be defined early, as other include files
		182	* will rely on this define as well.
		183	*/
		184	#define _DARWIN_UNLIMITED_SELECT 1
		185
167	#include <stdlib.h>	186	#include <stdlib.h>
168	#include <string.h>	187	#include <string.h>
169	#include <fcntl.h>	188	#include <fcntl.h>
170	#include <stddef.h>	189	#include <stddef.h>
171		190
…		…
201	# include <sys/wait.h>	220	# include <sys/wait.h>
202	# include <unistd.h>	221	# include <unistd.h>
203	#else	222	#else
204	# include <io.h>	223	# include <io.h>
205	# define WIN32_LEAN_AND_MEAN	224	# define WIN32_LEAN_AND_MEAN
		225	# include <winsock2.h>
206	# include <windows.h>	226	# include <windows.h>
207	# include <winsock2.h>
208	# ifndef EV_SELECT_IS_WINSOCKET	227	# ifndef EV_SELECT_IS_WINSOCKET
209	# define EV_SELECT_IS_WINSOCKET 1	228	# define EV_SELECT_IS_WINSOCKET 1
210	# endif	229	# endif
211	# undef EV_AVOID_STDIO	230	# undef EV_AVOID_STDIO
212	#endif	231	#endif
213
214	/* OS X, in its infinite idiocy, actually HARDCODES
215	* a limit of 1024 into their select. Where people have brains,
216	* OS X engineers apparently have a vacuum. Or maybe they were
217	* ordered to have a vacuum, or they do anything for money.
218	* This might help. Or not.
219	*/
220	#define _DARWIN_UNLIMITED_SELECT 1
221		232
222	/* this block tries to deduce configuration from header-defined symbols and defaults */	233	/* this block tries to deduce configuration from header-defined symbols and defaults */
223		234
224	/* try to deduce the maximum number of signals on this platform */	235	/* try to deduce the maximum number of signals on this platform */
225	#if defined EV_NSIG	236	#if defined EV_NSIG
…		…
241	#elif defined SIGARRAYSIZE	252	#elif defined SIGARRAYSIZE
242	# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */	253	# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
243	#elif defined _sys_nsig	254	#elif defined _sys_nsig
244	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */	255	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
245	#else	256	#else
246	# error "unable to find value for NSIG, please report"	257	# define EV_NSIG (8 * sizeof (sigset_t) + 1)
247	/* to make it compile regardless, just remove the above line, */
248	/* but consider reporting it, too! :) */
249	# define EV_NSIG 65
250	#endif	258	#endif
251		259
252	#ifndef EV_USE_FLOOR	260	#ifndef EV_USE_FLOOR
253	# define EV_USE_FLOOR 0	261	# define EV_USE_FLOOR 0
254	#endif	262	#endif
255		263
256	#ifndef EV_USE_CLOCK_SYSCALL	264	#ifndef EV_USE_CLOCK_SYSCALL
257	# if __linux && __GLIBC__ >= 2	265	# if __linux && __GLIBC__ == 2 && __GLIBC_MINOR__ < 17
258	# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS	266	# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
259	# else	267	# else
260	# define EV_USE_CLOCK_SYSCALL 0	268	# define EV_USE_CLOCK_SYSCALL 0
		269	# endif
		270	#endif
		271
		272	#if !(_POSIX_TIMERS > 0)
		273	# ifndef EV_USE_MONOTONIC
		274	# define EV_USE_MONOTONIC 0
		275	# endif
		276	# ifndef EV_USE_REALTIME
		277	# define EV_USE_REALTIME 0
261	# endif	278	# endif
262	#endif	279	#endif
263		280
264	#ifndef EV_USE_MONOTONIC	281	#ifndef EV_USE_MONOTONIC
265	# if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0	282	# if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
…		…
307		324
308	#ifndef EV_USE_PORT	325	#ifndef EV_USE_PORT
309	# define EV_USE_PORT 0	326	# define EV_USE_PORT 0
310	#endif	327	#endif
311		328
		329	#ifndef EV_USE_LINUXAIO
		330	# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */
		331	# define EV_USE_LINUXAIO 1
		332	# else
		333	# define EV_USE_LINUXAIO 0
		334	# endif
		335	#endif
		336
		337	#ifndef EV_USE_IOURING
		338	# if __linux
		339	# define EV_USE_IOURING 0
		340	# else
		341	# define EV_USE_IOURING 0
		342	# endif
		343	#endif
		344
312	#ifndef EV_USE_INOTIFY	345	#ifndef EV_USE_INOTIFY
313	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))	346	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
314	# define EV_USE_INOTIFY EV_FEATURE_OS	347	# define EV_USE_INOTIFY EV_FEATURE_OS
315	# else	348	# else
316	# define EV_USE_INOTIFY 0	349	# define EV_USE_INOTIFY 0
…		…
355	# define EV_USE_4HEAP EV_FEATURE_DATA	388	# define EV_USE_4HEAP EV_FEATURE_DATA
356	#endif	389	#endif
357		390
358	#ifndef EV_HEAP_CACHE_AT	391	#ifndef EV_HEAP_CACHE_AT
359	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA	392	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
		393	#endif
		394
		395	#ifdef __ANDROID__
		396	/* supposedly, android doesn't typedef fd_mask */
		397	# undef EV_USE_SELECT
		398	# define EV_USE_SELECT 0
		399	/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
		400	# undef EV_USE_CLOCK_SYSCALL
		401	# define EV_USE_CLOCK_SYSCALL 0
		402	#endif
		403
		404	/* aix's poll.h seems to cause lots of trouble */
		405	#ifdef _AIX
		406	/* AIX has a completely broken poll.h header */
		407	# undef EV_USE_POLL
		408	# define EV_USE_POLL 0
360	#endif	409	#endif
361		410
362	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */	411	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
363	/* which makes programs even slower. might work on other unices, too. */	412	/* which makes programs even slower. might work on other unices, too. */
364	#if EV_USE_CLOCK_SYSCALL	413	#if EV_USE_CLOCK_SYSCALL
365	# include <sys/syscall.h>	414	# include <sys/syscall.h>
366	# ifdef SYS_clock_gettime	415	# ifdef SYS_clock_gettime
367	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))	416	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
368	# undef EV_USE_MONOTONIC	417	# undef EV_USE_MONOTONIC
369	# define EV_USE_MONOTONIC 1	418	# define EV_USE_MONOTONIC 1
		419	# define EV_NEED_SYSCALL 1
370	# else	420	# else
371	# undef EV_USE_CLOCK_SYSCALL	421	# undef EV_USE_CLOCK_SYSCALL
372	# define EV_USE_CLOCK_SYSCALL 0	422	# define EV_USE_CLOCK_SYSCALL 0
373	# endif	423	# endif
374	#endif	424	#endif
375		425
376	/* this block fixes any misconfiguration where we know we run into trouble otherwise */	426	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
377		427
378	#ifdef _AIX
379	/* AIX has a completely broken poll.h header */
380	# undef EV_USE_POLL
381	# define EV_USE_POLL 0
382	#endif
383
384	#ifndef CLOCK_MONOTONIC	428	#ifndef CLOCK_MONOTONIC
385	# undef EV_USE_MONOTONIC	429	# undef EV_USE_MONOTONIC
386	# define EV_USE_MONOTONIC 0	430	# define EV_USE_MONOTONIC 0
387	#endif	431	#endif
388		432
…		…
398		442
399	#if !EV_USE_NANOSLEEP	443	#if !EV_USE_NANOSLEEP
400	/* hp-ux has it in sys/time.h, which we unconditionally include above */	444	/* hp-ux has it in sys/time.h, which we unconditionally include above */
401	# if !defined _WIN32 && !defined __hpux	445	# if !defined _WIN32 && !defined __hpux
402	# include <sys/select.h>	446	# include <sys/select.h>
		447	# endif
		448	#endif
		449
		450	#if EV_USE_LINUXAIO
		451	# include <sys/syscall.h>
		452	# if SYS_io_getevents && EV_USE_EPOLL /* linuxaio backend requires epoll backend */
		453	# define EV_NEED_SYSCALL 1
		454	# else
		455	# undef EV_USE_LINUXAIO
		456	# define EV_USE_LINUXAIO 0
		457	# endif
		458	#endif
		459
		460	#if EV_USE_IOURING
		461	# include <sys/syscall.h>
		462	# if !SYS_io_uring_setup && __linux && !__alpha
		463	# define SYS_io_uring_setup 425
		464	# define SYS_io_uring_enter 426
		465	# define SYS_io_uring_wregister 427
		466	# endif
		467	# if SYS_io_uring_setup && EV_USE_EPOLL /* iouring backend requires epoll backend */
		468	# define EV_NEED_SYSCALL 1
		469	# else
		470	# undef EV_USE_IOURING
		471	# define EV_USE_IOURING 0
403	# endif	472	# endif
404	#endif	473	#endif
405		474
406	#if EV_USE_INOTIFY	475	#if EV_USE_INOTIFY
407	# include <sys/statfs.h>	476	# include <sys/statfs.h>
…		…
449	uint32_t ssi_signo;	518	uint32_t ssi_signo;
450	char pad[128 - sizeof (uint32_t)];	519	char pad[128 - sizeof (uint32_t)];
451	};	520	};
452	#endif	521	#endif
453		522
454	/**/	523	/*****************************************************************************/
455		524
456	#if EV_VERIFY >= 3	525	#if EV_VERIFY >= 3
457	# define EV_FREQUENT_CHECK ev_verify (EV_A)	526	# define EV_FREQUENT_CHECK ev_verify (EV_A)
458	#else	527	#else
459	# define EV_FREQUENT_CHECK do { } while (0)	528	# define EV_FREQUENT_CHECK do { } while (0)
…		…
464	* This value is good at least till the year 4000.	533	* This value is good at least till the year 4000.
465	*/	534	*/
466	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */	535	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
467	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */	536	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
468		537
469	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	538	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
470	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	539	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
471		540
		541	/* find a portable timestamp that is "always" in the future but fits into time_t.
		542	* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
		543	* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
		544	#define EV_TSTAMP_HUGE \
		545	(sizeof (time_t) >= 8 ? 10000000000000. \
		546	: 0 < (time_t)4294967295 ? 4294967295. \
		547	: 2147483647.) \
		548
		549	#define EV_TS_TO_MSEC(a) a * 1e3 + 0.9999
		550	#define EV_TS_FROM_USEC(us) us * 1e-6
472	#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)	551	#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
473	#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)	552	#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
		553	#define EV_TV_GET(tv) ((tv).tv_sec + (tv).tv_usec * 1e-6)
		554	#define EV_TS_GET(ts) ((ts).tv_sec + (ts).tv_nsec * 1e-9)
474		555
475	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */	556	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
476	/* ECB.H BEGIN */	557	/* ECB.H BEGIN */
477	/*	558	/*
478	* libecb - http://software.schmorp.de/pkg/libecb	559	* libecb - http://software.schmorp.de/pkg/libecb
479	*	560	*
480	* Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>	561	* Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
481	* Copyright (©) 2011 Emanuele Giaquinta	562	* Copyright (©) 2011 Emanuele Giaquinta
482	* All rights reserved.	563	* All rights reserved.
483	*	564	*
484	* Redistribution and use in source and binary forms, with or without modifica-	565	* Redistribution and use in source and binary forms, with or without modifica-
485	* tion, are permitted provided that the following conditions are met:	566	* tion, are permitted provided that the following conditions are met:
…		…
499	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;	580	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
500	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,	581	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
501	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-	582	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
502	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED	583	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
503	* OF THE POSSIBILITY OF SUCH DAMAGE.	584	* OF THE POSSIBILITY OF SUCH DAMAGE.
		585	*
		586	* Alternatively, the contents of this file may be used under the terms of
		587	* the GNU General Public License ("GPL") version 2 or any later version,
		588	* in which case the provisions of the GPL are applicable instead of
		589	* the above. If you wish to allow the use of your version of this file
		590	* only under the terms of the GPL and not to allow others to use your
		591	* version of this file under the BSD license, indicate your decision
		592	* by deleting the provisions above and replace them with the notice
		593	* and other provisions required by the GPL. If you do not delete the
		594	* provisions above, a recipient may use your version of this file under
		595	* either the BSD or the GPL.
504	*/	596	*/
505		597
506	#ifndef ECB_H	598	#ifndef ECB_H
507	#define ECB_H	599	#define ECB_H
		600
		601	/* 16 bits major, 16 bits minor */
		602	#define ECB_VERSION 0x00010006
508		603
509	#ifdef _WIN32	604	#ifdef _WIN32
510	typedef signed char int8_t;	605	typedef signed char int8_t;
511	typedef unsigned char uint8_t;	606	typedef unsigned char uint8_t;
512	typedef signed short int16_t;	607	typedef signed short int16_t;
…		…
518	typedef unsigned long long uint64_t;	613	typedef unsigned long long uint64_t;
519	#else /* _MSC_VER || __BORLANDC__ */	614	#else /* _MSC_VER || __BORLANDC__ */
520	typedef signed __int64 int64_t;	615	typedef signed __int64 int64_t;
521	typedef unsigned __int64 uint64_t;	616	typedef unsigned __int64 uint64_t;
522	#endif	617	#endif
		618	#ifdef _WIN64
		619	#define ECB_PTRSIZE 8
		620	typedef uint64_t uintptr_t;
		621	typedef int64_t intptr_t;
		622	#else
		623	#define ECB_PTRSIZE 4
		624	typedef uint32_t uintptr_t;
		625	typedef int32_t intptr_t;
		626	#endif
523	#else	627	#else
524	#include <inttypes.h>	628	#include <inttypes.h>
		629	#if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
		630	#define ECB_PTRSIZE 8
		631	#else
		632	#define ECB_PTRSIZE 4
		633	#endif
		634	#endif
		635
		636	#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
		637	#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
		638
		639	/* work around x32 idiocy by defining proper macros */
		640	#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
		641	#if _ILP32
		642	#define ECB_AMD64_X32 1
		643	#else
		644	#define ECB_AMD64 1
		645	#endif
525	#endif	646	#endif
526		647
527	/* many compilers define _GNUC_ to some versions but then only implement	648	/* many compilers define _GNUC_ to some versions but then only implement
528	* what their idiot authors think are the "more important" extensions,	649	* what their idiot authors think are the "more important" extensions,
529	* causing enormous grief in return for some better fake benchmark numbers.	650	* causing enormous grief in return for some better fake benchmark numbers.
530	* or so.	651	* or so.
531	* we try to detect these and simply assume they are not gcc - if they have	652	* we try to detect these and simply assume they are not gcc - if they have
532	* an issue with that they should have done it right in the first place.	653	* an issue with that they should have done it right in the first place.
533	*/	654	*/
534	#ifndef ECB_GCC_VERSION
535	#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__	655	#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
536	#define ECB_GCC_VERSION(major,minor) 0	656	#define ECB_GCC_VERSION(major,minor) 0
537	#else	657	#else
538	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))	658	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
539	#endif	659	#endif
		660
		661	#define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
		662
		663	#if __clang__ && defined __has_builtin
		664	#define ECB_CLANG_BUILTIN(x) __has_builtin (x)
		665	#else
		666	#define ECB_CLANG_BUILTIN(x) 0
		667	#endif
		668
		669	#if __clang__ && defined __has_extension
		670	#define ECB_CLANG_EXTENSION(x) __has_extension (x)
		671	#else
		672	#define ECB_CLANG_EXTENSION(x) 0
		673	#endif
		674
		675	#define ECB_CPP (__cplusplus+0)
		676	#define ECB_CPP11 (__cplusplus >= 201103L)
		677	#define ECB_CPP14 (__cplusplus >= 201402L)
		678	#define ECB_CPP17 (__cplusplus >= 201703L)
		679
		680	#if ECB_CPP
		681	#define ECB_C 0
		682	#define ECB_STDC_VERSION 0
		683	#else
		684	#define ECB_C 1
		685	#define ECB_STDC_VERSION __STDC_VERSION__
		686	#endif
		687
		688	#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
		689	#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
		690	#define ECB_C17 (ECB_STDC_VERSION >= 201710L)
		691
		692	#if ECB_CPP
		693	#define ECB_EXTERN_C extern "C"
		694	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {
		695	#define ECB_EXTERN_C_END }
		696	#else
		697	#define ECB_EXTERN_C extern
		698	#define ECB_EXTERN_C_BEG
		699	#define ECB_EXTERN_C_END
540	#endif	700	#endif
541		701
542	/*****************************************************************************/	702	/*****************************************************************************/
543		703
544	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */	704	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
545	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */	705	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
546		706
547	#if ECB_NO_THREADS	707	#if ECB_NO_THREADS
548	# define ECB_NO_SMP 1	708	#define ECB_NO_SMP 1
549	#endif	709	#endif
550		710
551	#if ECB_NO_THREADS || ECB_NO_SMP	711	#if ECB_NO_SMP
552	#define ECB_MEMORY_FENCE do { } while (0)	712	#define ECB_MEMORY_FENCE do { } while (0)
		713	#endif
		714
		715	/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
		716	#if __xlC__ && ECB_CPP
		717	#include <builtins.h>
		718	#endif
		719
		720	#if 1400 <= _MSC_VER
		721	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
553	#endif	722	#endif
554		723
555	#ifndef ECB_MEMORY_FENCE	724	#ifndef ECB_MEMORY_FENCE
556	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	725	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
		726	#define ECB_MEMORY_FENCE_RELAXED __asm__ __volatile__ ("" : : : "memory")
557	#if __i386 || __i386__	727	#if __i386 || __i386__
558	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")	728	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
559	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */	729	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
560	#define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */	730	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
561	#elif __amd64 || __amd64__ || __x86_64 || __x86_64__	731	#elif ECB_GCC_AMD64
562	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")	732	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
563	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")	733	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
564	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */	734	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
565	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__	735	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
566	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	736	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
		737	#elif defined __ARM_ARCH_2__ \
		738	|| defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
		739	|| defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
		740	|| defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
		741	|| defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
		742	|| defined __ARM_ARCH_5TEJ__
		743	/* should not need any, unless running old code on newer cpu - arm doesn't support that */
567	#elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \	744	#elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
568	|| defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__	745	|| defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
		746	|| defined __ARM_ARCH_6T2__
569	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")	747	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
570	#elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \	748	#elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
571	|| defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__	749	|| defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
572	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")	750	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
573	#elif __sparc || __sparc__	751	#elif __aarch64__
		752	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
		753	#elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
574	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad | " : : : "memory")	754	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
575	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")	755	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
576	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")	756	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
577	#elif defined __s390__ || defined __s390x__	757	#elif defined __s390__ || defined __s390x__
578	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")	758	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
579	#elif defined __mips__	759	#elif defined __mips__
		760	/* GNU/Linux emulates sync on mips1 architectures, so we force its use */
		761	/* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
580	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	762	#define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
581	#elif defined __alpha__	763	#elif defined __alpha__
582	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")	764	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
		765	#elif defined __hppa__
		766	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		767	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
		768	#elif defined __ia64__
		769	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
		770	#elif defined __m68k__
		771	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		772	#elif defined __m88k__
		773	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
		774	#elif defined __sh__
		775	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
583	#endif	776	#endif
584	#endif	777	#endif
585	#endif	778	#endif
586		779
587	#ifndef ECB_MEMORY_FENCE	780	#ifndef ECB_MEMORY_FENCE
		781	#if ECB_GCC_VERSION(4,7)
		782	/* see comment below (stdatomic.h) about the C11 memory model. */
		783	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
		784	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
		785	#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
		786	#define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
		787
		788	#elif ECB_CLANG_EXTENSION(c_atomic)
		789	/* see comment below (stdatomic.h) about the C11 memory model. */
		790	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
		791	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
		792	#define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
		793	#define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
		794
588	#if ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__	795	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
589	#define ECB_MEMORY_FENCE __sync_synchronize ()	796	#define ECB_MEMORY_FENCE __sync_synchronize ()
590	/*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */	797	#elif _MSC_VER >= 1500 /* VC++ 2008 */
591	/*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */	798	/* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
		799	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
		800	#define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
		801	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
		802	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
592	#elif _MSC_VER >= 1400 /* VC++ 2005 */	803	#elif _MSC_VER >= 1400 /* VC++ 2005 */
593	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)	804	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
594	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()	805	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()
595	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */	806	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
596	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()	807	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
597	#elif defined _WIN32	808	#elif defined _WIN32
598	#include <WinNT.h>	809	#include <WinNT.h>
599	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */	810	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
600	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	811	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
601	#include <mbarrier.h>	812	#include <mbarrier.h>
602	#define ECB_MEMORY_FENCE __machine_rw_barrier ()	813	#define ECB_MEMORY_FENCE __machine_rw_barrier ()
603	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()	814	#define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
604	#define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()	815	#define ECB_MEMORY_FENCE_RELEASE __machine_rel_barrier ()
		816	#define ECB_MEMORY_FENCE_RELAXED __compiler_barrier ()
605	#elif __xlC__	817	#elif __xlC__
606	#define ECB_MEMORY_FENCE __sync ()	818	#define ECB_MEMORY_FENCE __sync ()
		819	#endif
		820	#endif
		821
		822	#ifndef ECB_MEMORY_FENCE
		823	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
		824	/* we assume that these memory fences work on all variables/all memory accesses, */
		825	/* not just C11 atomics and atomic accesses */
		826	#include <stdatomic.h>
		827	#define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
		828	#define ECB_MEMORY_FENCE_ACQUIRE atomic_thread_fence (memory_order_acquire)
		829	#define ECB_MEMORY_FENCE_RELEASE atomic_thread_fence (memory_order_release)
607	#endif	830	#endif
608	#endif	831	#endif
609		832
610	#ifndef ECB_MEMORY_FENCE	833	#ifndef ECB_MEMORY_FENCE
611	#if !ECB_AVOID_PTHREADS	834	#if !ECB_AVOID_PTHREADS
…		…
631		854
632	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE	855	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
633	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	856	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
634	#endif	857	#endif
635		858
		859	#if !defined ECB_MEMORY_FENCE_RELAXED && defined ECB_MEMORY_FENCE
		860	#define ECB_MEMORY_FENCE_RELAXED ECB_MEMORY_FENCE /* very heavy-handed */
		861	#endif
		862
636	/*****************************************************************************/	863	/*****************************************************************************/
637		864
638	#define ECB_C99 (__STDC_VERSION__ >= 199901L)	865	#if ECB_CPP
639
640	#if __cplusplus
641	#define ecb_inline static inline	866	#define ecb_inline static inline
642	#elif ECB_GCC_VERSION(2,5)	867	#elif ECB_GCC_VERSION(2,5)
643	#define ecb_inline static __inline__	868	#define ecb_inline static __inline__
644	#elif ECB_C99	869	#elif ECB_C99
645	#define ecb_inline static inline	870	#define ecb_inline static inline
…		…
659		884
660	#define ECB_CONCAT_(a, b) a ## b	885	#define ECB_CONCAT_(a, b) a ## b
661	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)	886	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
662	#define ECB_STRINGIFY_(a) # a	887	#define ECB_STRINGIFY_(a) # a
663	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)	888	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
		889	#define ECB_STRINGIFY_EXPR(expr) ((expr), ECB_STRINGIFY_ (expr))
664		890
665	#define ecb_function_ ecb_inline	891	#define ecb_function_ ecb_inline
666		892
667	#if ECB_GCC_VERSION(3,1)	893	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
668	#define ecb_attribute(attrlist) __attribute__(attrlist)	894	#define ecb_attribute(attrlist) __attribute__ (attrlist)
		895	#else
		896	#define ecb_attribute(attrlist)
		897	#endif
		898
		899	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
669	#define ecb_is_constant(expr) __builtin_constant_p (expr)	900	#define ecb_is_constant(expr) __builtin_constant_p (expr)
		901	#else
		902	/* possible C11 impl for integral types
		903	typedef struct ecb_is_constant_struct ecb_is_constant_struct;
		904	#define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
		905
		906	#define ecb_is_constant(expr) 0
		907	#endif
		908
		909	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
670	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))	910	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
		911	#else
		912	#define ecb_expect(expr,value) (expr)
		913	#endif
		914
		915	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
671	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)	916	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
672	#else	917	#else
673	#define ecb_attribute(attrlist)
674	#define ecb_is_constant(expr) 0
675	#define ecb_expect(expr,value) (expr)
676	#define ecb_prefetch(addr,rw,locality)	918	#define ecb_prefetch(addr,rw,locality)
677	#endif	919	#endif
678		920
679	/* no emulation for ecb_decltype */	921	/* no emulation for ecb_decltype */
680	#if ECB_GCC_VERSION(4,5)	922	#if ECB_CPP11
		923	// older implementations might have problems with decltype(x)::type, work around it
		924	template<class T> struct ecb_decltype_t { typedef T type; };
681	#define ecb_decltype(x) __decltype(x)	925	#define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
682	#elif ECB_GCC_VERSION(3,0)	926	#elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
683	#define ecb_decltype(x) __typeof(x)	927	#define ecb_decltype(x) __typeof__ (x)
684	#endif	928	#endif
685		929
		930	#if _MSC_VER >= 1300
		931	#define ecb_deprecated __declspec (deprecated)
		932	#else
		933	#define ecb_deprecated ecb_attribute ((__deprecated__))
		934	#endif
		935
		936	#if _MSC_VER >= 1500
		937	#define ecb_deprecated_message(msg) __declspec (deprecated (msg))
		938	#elif ECB_GCC_VERSION(4,5)
		939	#define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg))
		940	#else
		941	#define ecb_deprecated_message(msg) ecb_deprecated
		942	#endif
		943
		944	#if _MSC_VER >= 1400
		945	#define ecb_noinline __declspec (noinline)
		946	#else
686	#define ecb_noinline ecb_attribute ((__noinline__))	947	#define ecb_noinline ecb_attribute ((__noinline__))
687	#define ecb_noreturn ecb_attribute ((__noreturn__))	948	#endif
		949
688	#define ecb_unused ecb_attribute ((__unused__))	950	#define ecb_unused ecb_attribute ((__unused__))
689	#define ecb_const ecb_attribute ((__const__))	951	#define ecb_const ecb_attribute ((__const__))
690	#define ecb_pure ecb_attribute ((__pure__))	952	#define ecb_pure ecb_attribute ((__pure__))
		953
		954	#if ECB_C11 || __IBMC_NORETURN
		955	/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/language_ref/noreturn.html */
		956	#define ecb_noreturn _Noreturn
		957	#elif ECB_CPP11
		958	#define ecb_noreturn [[noreturn]]
		959	#elif _MSC_VER >= 1200
		960	/* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */
		961	#define ecb_noreturn __declspec (noreturn)
		962	#else
		963	#define ecb_noreturn ecb_attribute ((__noreturn__))
		964	#endif
691		965
692	#if ECB_GCC_VERSION(4,3)	966	#if ECB_GCC_VERSION(4,3)
693	#define ecb_artificial ecb_attribute ((__artificial__))	967	#define ecb_artificial ecb_attribute ((__artificial__))
694	#define ecb_hot ecb_attribute ((__hot__))	968	#define ecb_hot ecb_attribute ((__hot__))
695	#define ecb_cold ecb_attribute ((__cold__))	969	#define ecb_cold ecb_attribute ((__cold__))
…		…
707	/* for compatibility to the rest of the world */	981	/* for compatibility to the rest of the world */
708	#define ecb_likely(expr) ecb_expect_true (expr)	982	#define ecb_likely(expr) ecb_expect_true (expr)
709	#define ecb_unlikely(expr) ecb_expect_false (expr)	983	#define ecb_unlikely(expr) ecb_expect_false (expr)
710		984
711	/* count trailing zero bits and count # of one bits */	985	/* count trailing zero bits and count # of one bits */
712	#if ECB_GCC_VERSION(3,4)	986	#if ECB_GCC_VERSION(3,4) \
		987	|| (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
		988	&& ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
		989	&& ECB_CLANG_BUILTIN(__builtin_popcount))
713	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */	990	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
714	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)	991	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)
715	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)	992	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
716	#define ecb_ctz32(x) __builtin_ctz (x)	993	#define ecb_ctz32(x) __builtin_ctz (x)
717	#define ecb_ctz64(x) __builtin_ctzll (x)	994	#define ecb_ctz64(x) __builtin_ctzll (x)
718	#define ecb_popcount32(x) __builtin_popcount (x)	995	#define ecb_popcount32(x) __builtin_popcount (x)
719	/* no popcountll */	996	/* no popcountll */
720	#else	997	#else
721	ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;	998	ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
722	ecb_function_ int	999	ecb_function_ ecb_const int
723	ecb_ctz32 (uint32_t x)	1000	ecb_ctz32 (uint32_t x)
724	{	1001	{
		1002	#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
		1003	unsigned long r;
		1004	_BitScanForward (&r, x);
		1005	return (int)r;
		1006	#else
725	int r = 0;	1007	int r = 0;
726		1008
727	x &= ~x + 1; /* this isolates the lowest bit */	1009	x &= ~x + 1; /* this isolates the lowest bit */
728		1010
729	#if ECB_branchless_on_i386	1011	#if ECB_branchless_on_i386
…		…
739	if (x & 0xff00ff00) r += 8;	1021	if (x & 0xff00ff00) r += 8;
740	if (x & 0xffff0000) r += 16;	1022	if (x & 0xffff0000) r += 16;
741	#endif	1023	#endif
742		1024
743	return r;	1025	return r;
		1026	#endif
744	}	1027	}
745		1028
746	ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;	1029	ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
747	ecb_function_ int	1030	ecb_function_ ecb_const int
748	ecb_ctz64 (uint64_t x)	1031	ecb_ctz64 (uint64_t x)
749	{	1032	{
		1033	#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
		1034	unsigned long r;
		1035	_BitScanForward64 (&r, x);
		1036	return (int)r;
		1037	#else
750	int shift = x & 0xffffffffU ? 0 : 32;	1038	int shift = x & 0xffffffff ? 0 : 32;
751	return ecb_ctz32 (x >> shift) + shift;	1039	return ecb_ctz32 (x >> shift) + shift;
		1040	#endif
752	}	1041	}
753		1042
754	ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;	1043	ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
755	ecb_function_ int	1044	ecb_function_ ecb_const int
756	ecb_popcount32 (uint32_t x)	1045	ecb_popcount32 (uint32_t x)
757	{	1046	{
758	x -= (x >> 1) & 0x55555555;	1047	x -= (x >> 1) & 0x55555555;
759	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);	1048	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
760	x = ((x >> 4) + x) & 0x0f0f0f0f;	1049	x = ((x >> 4) + x) & 0x0f0f0f0f;
761	x *= 0x01010101;	1050	x *= 0x01010101;
762		1051
763	return x >> 24;	1052	return x >> 24;
764	}	1053	}
765		1054
766	ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;	1055	ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
767	ecb_function_ int ecb_ld32 (uint32_t x)	1056	ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
768	{	1057	{
		1058	#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
		1059	unsigned long r;
		1060	_BitScanReverse (&r, x);
		1061	return (int)r;
		1062	#else
769	int r = 0;	1063	int r = 0;
770		1064
771	if (x >> 16) { x >>= 16; r += 16; }	1065	if (x >> 16) { x >>= 16; r += 16; }
772	if (x >> 8) { x >>= 8; r += 8; }	1066	if (x >> 8) { x >>= 8; r += 8; }
773	if (x >> 4) { x >>= 4; r += 4; }	1067	if (x >> 4) { x >>= 4; r += 4; }
774	if (x >> 2) { x >>= 2; r += 2; }	1068	if (x >> 2) { x >>= 2; r += 2; }
775	if (x >> 1) { r += 1; }	1069	if (x >> 1) { r += 1; }
776		1070
777	return r;	1071	return r;
		1072	#endif
778	}	1073	}
779		1074
780	ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;	1075	ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
781	ecb_function_ int ecb_ld64 (uint64_t x)	1076	ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
782	{	1077	{
		1078	#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
		1079	unsigned long r;
		1080	_BitScanReverse64 (&r, x);
		1081	return (int)r;
		1082	#else
783	int r = 0;	1083	int r = 0;
784		1084
785	if (x >> 32) { x >>= 32; r += 32; }	1085	if (x >> 32) { x >>= 32; r += 32; }
786		1086
787	return r + ecb_ld32 (x);	1087	return r + ecb_ld32 (x);
		1088	#endif
788	}	1089	}
789	#endif	1090	#endif
790		1091
		1092	ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
		1093	ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
		1094	ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
		1095	ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
		1096
791	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;	1097	ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
792	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)	1098	ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
793	{	1099	{
794	return ( (x * 0x0802U & 0x22110U)	1100	return ( (x * 0x0802U & 0x22110U)
795	| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;	1101	| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
796	}	1102	}
797		1103
798	ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;	1104	ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
799	ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)	1105	ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
800	{	1106	{
801	x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);	1107	x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
802	x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);	1108	x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
803	x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);	1109	x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
804	x = ( x >> 8 ) | ( x << 8);	1110	x = ( x >> 8 ) | ( x << 8);
805		1111
806	return x;	1112	return x;
807	}	1113	}
808		1114
809	ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;	1115	ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
810	ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)	1116	ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
811	{	1117	{
812	x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);	1118	x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
813	x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);	1119	x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
814	x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);	1120	x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
815	x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);	1121	x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
…		…
818	return x;	1124	return x;
819	}	1125	}
820		1126
821	/* popcount64 is only available on 64 bit cpus as gcc builtin */	1127	/* popcount64 is only available on 64 bit cpus as gcc builtin */
822	/* so for this version we are lazy */	1128	/* so for this version we are lazy */
823	ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;	1129	ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
824	ecb_function_ int	1130	ecb_function_ ecb_const int
825	ecb_popcount64 (uint64_t x)	1131	ecb_popcount64 (uint64_t x)
826	{	1132	{
827	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);	1133	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
828	}	1134	}
829		1135
830	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;	1136	ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count);
831	ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;	1137	ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count);
832	ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;	1138	ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count);
833	ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;	1139	ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count);
834	ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;	1140	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count);
835	ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;	1141	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count);
836	ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;	1142	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count);
837	ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;	1143	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
838		1144
839	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }	1145	ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
840	ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }	1146	ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
841	ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }	1147	ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
842	ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }	1148	ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
843	ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }	1149	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
844	ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }	1150	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
845	ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }	1151	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
846	ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }	1152	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
847		1153
848	#if ECB_GCC_VERSION(4,3)	1154	#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
		1155	#if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
		1156	#define ecb_bswap16(x) __builtin_bswap16 (x)
		1157	#else
849	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)	1158	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
		1159	#endif
850	#define ecb_bswap32(x) __builtin_bswap32 (x)	1160	#define ecb_bswap32(x) __builtin_bswap32 (x)
851	#define ecb_bswap64(x) __builtin_bswap64 (x)	1161	#define ecb_bswap64(x) __builtin_bswap64 (x)
		1162	#elif _MSC_VER
		1163	#include <stdlib.h>
		1164	#define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
		1165	#define ecb_bswap32(x) ((uint32_t)_byteswap_ulong ((uint32_t)(x)))
		1166	#define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
852	#else	1167	#else
853	ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;	1168	ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
854	ecb_function_ uint16_t	1169	ecb_function_ ecb_const uint16_t
855	ecb_bswap16 (uint16_t x)	1170	ecb_bswap16 (uint16_t x)
856	{	1171	{
857	return ecb_rotl16 (x, 8);	1172	return ecb_rotl16 (x, 8);
858	}	1173	}
859		1174
860	ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;	1175	ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
861	ecb_function_ uint32_t	1176	ecb_function_ ecb_const uint32_t
862	ecb_bswap32 (uint32_t x)	1177	ecb_bswap32 (uint32_t x)
863	{	1178	{
864	return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);	1179	return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
865	}	1180	}
866		1181
867	ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;	1182	ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
868	ecb_function_ uint64_t	1183	ecb_function_ ecb_const uint64_t
869	ecb_bswap64 (uint64_t x)	1184	ecb_bswap64 (uint64_t x)
870	{	1185	{
871	return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);	1186	return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
872	}	1187	}
873	#endif	1188	#endif
874		1189
875	#if ECB_GCC_VERSION(4,5)	1190	#if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
876	#define ecb_unreachable() __builtin_unreachable ()	1191	#define ecb_unreachable() __builtin_unreachable ()
877	#else	1192	#else
878	/* this seems to work fine, but gcc always emits a warning for it :/ */	1193	/* this seems to work fine, but gcc always emits a warning for it :/ */
879	ecb_inline void ecb_unreachable (void) ecb_noreturn;	1194	ecb_inline ecb_noreturn void ecb_unreachable (void);
880	ecb_inline void ecb_unreachable (void) { }	1195	ecb_inline ecb_noreturn void ecb_unreachable (void) { }
881	#endif	1196	#endif
882		1197
883	/* try to tell the compiler that some condition is definitely true */	1198	/* try to tell the compiler that some condition is definitely true */
884	#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)	1199	#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
885		1200
886	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;	1201	ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
887	ecb_inline unsigned char	1202	ecb_inline ecb_const uint32_t
888	ecb_byteorder_helper (void)	1203	ecb_byteorder_helper (void)
889	{	1204	{
890	const uint32_t u = 0x11223344;	1205	/* the union code still generates code under pressure in gcc, */
891	return *(unsigned char *)&u;	1206	/* but less than using pointers, and always seems to */
		1207	/* successfully return a constant. */
		1208	/* the reason why we have this horrible preprocessor mess */
		1209	/* is to avoid it in all cases, at least on common architectures */
		1210	/* or when using a recent enough gcc version (>= 4.6) */
		1211	#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
		1212	|| ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
		1213	#define ECB_LITTLE_ENDIAN 1
		1214	return 0x44332211;
		1215	#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
		1216	|| ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
		1217	#define ECB_BIG_ENDIAN 1
		1218	return 0x11223344;
		1219	#else
		1220	union
		1221	{
		1222	uint8_t c[4];
		1223	uint32_t u;
		1224	} u = { 0x11, 0x22, 0x33, 0x44 };
		1225	return u.u;
		1226	#endif
892	}	1227	}
893		1228
894	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;	1229	ecb_inline ecb_const ecb_bool ecb_big_endian (void);
895	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }	1230	ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
896	ecb_inline ecb_bool ecb_little_endian (void) ecb_const;	1231	ecb_inline ecb_const ecb_bool ecb_little_endian (void);
897	ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }	1232	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
898		1233
899	#if ECB_GCC_VERSION(3,0) || ECB_C99	1234	#if ECB_GCC_VERSION(3,0) || ECB_C99
900	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))	1235	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
901	#else	1236	#else
902	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))	1237	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
903	#endif	1238	#endif
904		1239
905	#if __cplusplus	1240	#if ECB_CPP
906	template<typename T>	1241	template<typename T>
907	static inline T ecb_div_rd (T val, T div)	1242	static inline T ecb_div_rd (T val, T div)
908	{	1243	{
909	return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;	1244	return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
910	}	1245	}
…		…
927	}	1262	}
928	#else	1263	#else
929	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	1264	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
930	#endif	1265	#endif
931		1266
		1267	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
		1268	ecb_function_ ecb_const uint32_t
		1269	ecb_binary16_to_binary32 (uint32_t x)
		1270	{
		1271	unsigned int s = (x & 0x8000) << (31 - 15);
		1272	int e = (x >> 10) & 0x001f;
		1273	unsigned int m = x & 0x03ff;
		1274
		1275	if (ecb_expect_false (e == 31))
		1276	/* infinity or NaN */
		1277	e = 255 - (127 - 15);
		1278	else if (ecb_expect_false (!e))
		1279	{
		1280	if (ecb_expect_true (!m))
		1281	/* zero, handled by code below by forcing e to 0 */
		1282	e = 0 - (127 - 15);
		1283	else
		1284	{
		1285	/* subnormal, renormalise */
		1286	unsigned int s = 10 - ecb_ld32 (m);
		1287
		1288	m = (m << s) & 0x3ff; /* mask implicit bit */
		1289	e -= s - 1;
		1290	}
		1291	}
		1292
		1293	/* e and m now are normalised, or zero, (or inf or nan) */
		1294	e += 127 - 15;
		1295
		1296	return s | (e << 23) | (m << (23 - 10));
		1297	}
		1298
		1299	ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
		1300	ecb_function_ ecb_const uint16_t
		1301	ecb_binary32_to_binary16 (uint32_t x)
		1302	{
		1303	unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
		1304	unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
		1305	unsigned int m = x & 0x007fffff;
		1306
		1307	x &= 0x7fffffff;
		1308
		1309	/* if it's within range of binary16 normals, use fast path */
		1310	if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
		1311	{
		1312	/* mantissa round-to-even */
		1313	m += 0x00000fff + ((m >> (23 - 10)) & 1);
		1314
		1315	/* handle overflow */
		1316	if (ecb_expect_false (m >= 0x00800000))
		1317	{
		1318	m >>= 1;
		1319	e += 1;
		1320	}
		1321
		1322	return s | (e << 10) | (m >> (23 - 10));
		1323	}
		1324
		1325	/* handle large numbers and infinity */
		1326	if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
		1327	return s | 0x7c00;
		1328
		1329	/* handle zero, subnormals and small numbers */
		1330	if (ecb_expect_true (x < 0x38800000))
		1331	{
		1332	/* zero */
		1333	if (ecb_expect_true (!x))
		1334	return s;
		1335
		1336	/* handle subnormals */
		1337
		1338	/* too small, will be zero */
		1339	if (e < (14 - 24)) /* might not be sharp, but is good enough */
		1340	return s;
		1341
		1342	m |= 0x00800000; /* make implicit bit explicit */
		1343
		1344	/* very tricky - we need to round to the nearest e (+10) bit value */
		1345	{
		1346	unsigned int bits = 14 - e;
		1347	unsigned int half = (1 << (bits - 1)) - 1;
		1348	unsigned int even = (m >> bits) & 1;
		1349
		1350	/* if this overflows, we will end up with a normalised number */
		1351	m = (m + half + even) >> bits;
		1352	}
		1353
		1354	return s | m;
		1355	}
		1356
		1357	/* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
		1358	m >>= 13;
		1359
		1360	return s | 0x7c00 | m | !m;
		1361	}
		1362
		1363	/*******************************************************************************/
		1364	/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
		1365
		1366	/* basically, everything uses "ieee pure-endian" floating point numbers */
		1367	/* the only noteworthy exception is ancient armle, which uses order 43218765 */
		1368	#if 0 \
		1369	|| __i386 || __i386__ \
		1370	|| ECB_GCC_AMD64 \
		1371	|| __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
		1372	|| defined __s390__ || defined __s390x__ \
		1373	|| defined __mips__ \
		1374	|| defined __alpha__ \
		1375	|| defined __hppa__ \
		1376	|| defined __ia64__ \
		1377	|| defined __m68k__ \
		1378	|| defined __m88k__ \
		1379	|| defined __sh__ \
		1380	|| defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
		1381	|| (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
		1382	|| defined __aarch64__
		1383	#define ECB_STDFP 1
		1384	#include <string.h> /* for memcpy */
		1385	#else
		1386	#define ECB_STDFP 0
		1387	#endif
		1388
		1389	#ifndef ECB_NO_LIBM
		1390
		1391	#include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
		1392
		1393	/* only the oldest of old doesn't have this one. solaris. */
		1394	#ifdef INFINITY
		1395	#define ECB_INFINITY INFINITY
		1396	#else
		1397	#define ECB_INFINITY HUGE_VAL
		1398	#endif
		1399
		1400	#ifdef NAN
		1401	#define ECB_NAN NAN
		1402	#else
		1403	#define ECB_NAN ECB_INFINITY
		1404	#endif
		1405
		1406	#if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
		1407	#define ecb_ldexpf(x,e) ldexpf ((x), (e))
		1408	#define ecb_frexpf(x,e) frexpf ((x), (e))
		1409	#else
		1410	#define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
		1411	#define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
		1412	#endif
		1413
		1414	/* convert a float to ieee single/binary32 */
		1415	ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
		1416	ecb_function_ ecb_const uint32_t
		1417	ecb_float_to_binary32 (float x)
		1418	{
		1419	uint32_t r;
		1420
		1421	#if ECB_STDFP
		1422	memcpy (&r, &x, 4);
		1423	#else
		1424	/* slow emulation, works for anything but -0 */
		1425	uint32_t m;
		1426	int e;
		1427
		1428	if (x == 0e0f ) return 0x00000000U;
		1429	if (x > +3.40282346638528860e+38f) return 0x7f800000U;
		1430	if (x < -3.40282346638528860e+38f) return 0xff800000U;
		1431	if (x != x ) return 0x7fbfffffU;
		1432
		1433	m = ecb_frexpf (x, &e) * 0x1000000U;
		1434
		1435	r = m & 0x80000000U;
		1436
		1437	if (r)
		1438	m = -m;
		1439
		1440	if (e <= -126)
		1441	{
		1442	m &= 0xffffffU;
		1443	m >>= (-125 - e);
		1444	e = -126;
		1445	}
		1446
		1447	r |= (e + 126) << 23;
		1448	r |= m & 0x7fffffU;
		1449	#endif
		1450
		1451	return r;
		1452	}
		1453
		1454	/* converts an ieee single/binary32 to a float */
		1455	ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
		1456	ecb_function_ ecb_const float
		1457	ecb_binary32_to_float (uint32_t x)
		1458	{
		1459	float r;
		1460
		1461	#if ECB_STDFP
		1462	memcpy (&r, &x, 4);
		1463	#else
		1464	/* emulation, only works for normals and subnormals and +0 */
		1465	int neg = x >> 31;
		1466	int e = (x >> 23) & 0xffU;
		1467
		1468	x &= 0x7fffffU;
		1469
		1470	if (e)
		1471	x |= 0x800000U;
		1472	else
		1473	e = 1;
		1474
		1475	/* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
		1476	r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
		1477
		1478	r = neg ? -r : r;
		1479	#endif
		1480
		1481	return r;
		1482	}
		1483
		1484	/* convert a double to ieee double/binary64 */
		1485	ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
		1486	ecb_function_ ecb_const uint64_t
		1487	ecb_double_to_binary64 (double x)
		1488	{
		1489	uint64_t r;
		1490
		1491	#if ECB_STDFP
		1492	memcpy (&r, &x, 8);
		1493	#else
		1494	/* slow emulation, works for anything but -0 */
		1495	uint64_t m;
		1496	int e;
		1497
		1498	if (x == 0e0 ) return 0x0000000000000000U;
		1499	if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
		1500	if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
		1501	if (x != x ) return 0X7ff7ffffffffffffU;
		1502
		1503	m = frexp (x, &e) * 0x20000000000000U;
		1504
		1505	r = m & 0x8000000000000000;;
		1506
		1507	if (r)
		1508	m = -m;
		1509
		1510	if (e <= -1022)
		1511	{
		1512	m &= 0x1fffffffffffffU;
		1513	m >>= (-1021 - e);
		1514	e = -1022;
		1515	}
		1516
		1517	r |= ((uint64_t)(e + 1022)) << 52;
		1518	r |= m & 0xfffffffffffffU;
		1519	#endif
		1520
		1521	return r;
		1522	}
		1523
		1524	/* converts an ieee double/binary64 to a double */
		1525	ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
		1526	ecb_function_ ecb_const double
		1527	ecb_binary64_to_double (uint64_t x)
		1528	{
		1529	double r;
		1530
		1531	#if ECB_STDFP
		1532	memcpy (&r, &x, 8);
		1533	#else
		1534	/* emulation, only works for normals and subnormals and +0 */
		1535	int neg = x >> 63;
		1536	int e = (x >> 52) & 0x7ffU;
		1537
		1538	x &= 0xfffffffffffffU;
		1539
		1540	if (e)
		1541	x |= 0x10000000000000U;
		1542	else
		1543	e = 1;
		1544
		1545	/* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
		1546	r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
		1547
		1548	r = neg ? -r : r;
		1549	#endif
		1550
		1551	return r;
		1552	}
		1553
		1554	/* convert a float to ieee half/binary16 */
		1555	ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
		1556	ecb_function_ ecb_const uint16_t
		1557	ecb_float_to_binary16 (float x)
		1558	{
		1559	return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
		1560	}
		1561
		1562	/* convert an ieee half/binary16 to float */
		1563	ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
		1564	ecb_function_ ecb_const float
		1565	ecb_binary16_to_float (uint16_t x)
		1566	{
		1567	return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
		1568	}
		1569
		1570	#endif
		1571
932	#endif	1572	#endif
933		1573
934	/* ECB.H END */	1574	/* ECB.H END */
935		1575
936	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1576	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
937	/* if your architecture doesn't need memory fences, e.g. because it is	1577	/* if your architecture doesn't need memory fences, e.g. because it is
938	* single-cpu/core, or if you use libev in a project that doesn't use libev	1578	* single-cpu/core, or if you use libev in a project that doesn't use libev
939	* from multiple threads, then you can define ECB_AVOID_PTHREADS when compiling	1579	* from multiple threads, then you can define ECB_NO_THREADS when compiling
940	* libev, in which cases the memory fences become nops.	1580	* libev, in which cases the memory fences become nops.
941	* alternatively, you can remove this #error and link against libpthread,	1581	* alternatively, you can remove this #error and link against libpthread,
942	* which will then provide the memory fences.	1582	* which will then provide the memory fences.
943	*/	1583	*/
944	# error "memory fences not defined for your architecture, please report"	1584	# error "memory fences not defined for your architecture, please report"
…		…
948	# define ECB_MEMORY_FENCE do { } while (0)	1588	# define ECB_MEMORY_FENCE do { } while (0)
949	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	1589	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
950	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	1590	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
951	#endif	1591	#endif
952		1592
953	#define expect_false(cond) ecb_expect_false (cond)
954	#define expect_true(cond) ecb_expect_true (cond)
955	#define noinline ecb_noinline
956
957	#define inline_size ecb_inline	1593	#define inline_size ecb_inline
958		1594
959	#if EV_FEATURE_CODE	1595	#if EV_FEATURE_CODE
960	# define inline_speed ecb_inline	1596	# define inline_speed ecb_inline
961	#else	1597	#else
962	# define inline_speed static noinline	1598	# define inline_speed ecb_noinline static
963	#endif	1599	#endif
		1600
		1601	/*****************************************************************************/
		1602	/* raw syscall wrappers */
		1603
		1604	#if EV_NEED_SYSCALL
		1605
		1606	#include <sys/syscall.h>
		1607
		1608	/*
		1609	* define some syscall wrappers for common architectures
		1610	* this is mostly for nice looks during debugging, not performance.
		1611	* our syscalls return < 0, not == -1, on error. which is good
		1612	* enough for linux aio.
		1613	* TODO: arm is also common nowadays, maybe even mips and x86
		1614	* TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
		1615	*/
		1616	#if __GNUC__ && __linux && ECB_AMD64 && !defined __OPTIMIZE_SIZE__
		1617	/* the costly errno access probably kills this for size optimisation */
		1618
		1619	#define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5,arg6) \
		1620	({ \
		1621	long res; \
		1622	register unsigned long r6 __asm__ ("r9" ); \
		1623	register unsigned long r5 __asm__ ("r8" ); \
		1624	register unsigned long r4 __asm__ ("r10"); \
		1625	register unsigned long r3 __asm__ ("rdx"); \
		1626	register unsigned long r2 __asm__ ("rsi"); \
		1627	register unsigned long r1 __asm__ ("rdi"); \
		1628	if (narg >= 6) r6 = (unsigned long)(arg6); \
		1629	if (narg >= 5) r5 = (unsigned long)(arg5); \
		1630	if (narg >= 4) r4 = (unsigned long)(arg4); \
		1631	if (narg >= 3) r3 = (unsigned long)(arg3); \
		1632	if (narg >= 2) r2 = (unsigned long)(arg2); \
		1633	if (narg >= 1) r1 = (unsigned long)(arg1); \
		1634	__asm__ __volatile__ ( \
		1635	"syscall\n\t" \
		1636	: "=a" (res) \
		1637	: "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
		1638	: "cc", "r11", "cx", "memory"); \
		1639	errno = -res; \
		1640	res; \
		1641	})
		1642
		1643	#endif
		1644
		1645	#ifdef ev_syscall
		1646	#define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0, 0)
		1647	#define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0, 0)
		1648	#define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0, 0)
		1649	#define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0, 0)
		1650	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0, 0)
		1651	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5, 0)
		1652	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) ev_syscall (nr, 6, arg1, arg2, arg3, arg4, arg5,arg6)
		1653	#else
		1654	#define ev_syscall0(nr) syscall (nr)
		1655	#define ev_syscall1(nr,arg1) syscall (nr, arg1)
		1656	#define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
		1657	#define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
		1658	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
		1659	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
		1660	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) syscall (nr, arg1, arg2, arg3, arg4, arg5,arg6)
		1661	#endif
		1662
		1663	#endif
		1664
		1665	/*****************************************************************************/
964		1666
965	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1667	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
966		1668
967	#if EV_MINPRI == EV_MAXPRI	1669	#if EV_MINPRI == EV_MAXPRI
968	# define ABSPRI(w) (((W)w), 0)	1670	# define ABSPRI(w) (((W)w), 0)
969	#else	1671	#else
970	# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)	1672	# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
971	#endif	1673	#endif
972		1674
973	#define EMPTY /* required for microsofts broken pseudo-c compiler */	1675	#define EMPTY /* required for microsofts broken pseudo-c compiler */
974	#define EMPTY2(a,b) /* used to suppress some warnings */
975		1676
976	typedef ev_watcher *W;	1677	typedef ev_watcher *W;
977	typedef ev_watcher_list *WL;	1678	typedef ev_watcher_list *WL;
978	typedef ev_watcher_time *WT;	1679	typedef ev_watcher_time *WT;
979		1680
…		…
1004	# include "ev_win32.c"	1705	# include "ev_win32.c"
1005	#endif	1706	#endif
1006		1707
1007	/*****************************************************************************/	1708	/*****************************************************************************/
1008		1709
		1710	#if EV_USE_LINUXAIO
		1711	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
		1712	#endif
		1713
1009	/* define a suitable floor function (only used by periodics atm) */	1714	/* define a suitable floor function (only used by periodics atm) */
1010		1715
1011	#if EV_USE_FLOOR	1716	#if EV_USE_FLOOR
1012	# include <math.h>	1717	# include <math.h>
1013	# define ev_floor(v) floor (v)	1718	# define ev_floor(v) floor (v)
1014	#else	1719	#else
1015		1720
1016	#include <float.h>	1721	#include <float.h>
1017		1722
1018	/* a floor() replacement function, should be independent of ev_tstamp type */	1723	/* a floor() replacement function, should be independent of ev_tstamp type */
		1724	ecb_noinline
1019	static ev_tstamp noinline	1725	static ev_tstamp
1020	ev_floor (ev_tstamp v)	1726	ev_floor (ev_tstamp v)
1021	{	1727	{
1022	/* the choice of shift factor is not terribly important */	1728	/* the choice of shift factor is not terribly important */
1023	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1729	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1024	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1730	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1025	#else	1731	#else
1026	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1732	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1027	#endif	1733	#endif
1028		1734
		1735	/* special treatment for negative arguments */
		1736	if (ecb_expect_false (v < 0.))
		1737	{
		1738	ev_tstamp f = -ev_floor (-v);
		1739
		1740	return f - (f == v ? 0 : 1);
		1741	}
		1742
1029	/* argument too large for an unsigned long? */	1743	/* argument too large for an unsigned long? then reduce it */
1030	if (expect_false (v >= shift))	1744	if (ecb_expect_false (v >= shift))
1031	{	1745	{
1032	ev_tstamp f;	1746	ev_tstamp f;
1033		1747
1034	if (v == v - 1.)	1748	if (v == v - 1.)
1035	return v; /* very large number */	1749	return v; /* very large numbers are assumed to be integer */
1036		1750
1037	f = shift * ev_floor (v * (1. / shift));	1751	f = shift * ev_floor (v * (1. / shift));
1038	return f + ev_floor (v - f);	1752	return f + ev_floor (v - f);
1039	}	1753	}
1040		1754
1041	/* special treatment for negative args? */
1042	if (expect_false (v < 0.))
1043	{
1044	ev_tstamp f = -ev_floor (-v);
1045
1046	return f - (f == v ? 0 : 1);
1047	}
1048
1049	/* fits into an unsigned long */	1755	/* fits into an unsigned long */
1050	return (unsigned long)v;	1756	return (unsigned long)v;
1051	}	1757	}
1052		1758
1053	#endif	1759	#endif
…		…
1056		1762
1057	#ifdef __linux	1763	#ifdef __linux
1058	# include <sys/utsname.h>	1764	# include <sys/utsname.h>
1059	#endif	1765	#endif
1060		1766
1061	static unsigned int noinline ecb_cold	1767	ecb_noinline ecb_cold
		1768	static unsigned int
1062	ev_linux_version (void)	1769	ev_linux_version (void)
1063	{	1770	{
1064	#ifdef __linux	1771	#ifdef __linux
1065	unsigned int v = 0;	1772	unsigned int v = 0;
1066	struct utsname buf;	1773	struct utsname buf;
…		…
1095	}	1802	}
1096		1803
1097	/*****************************************************************************/	1804	/*****************************************************************************/
1098		1805
1099	#if EV_AVOID_STDIO	1806	#if EV_AVOID_STDIO
1100	static void noinline ecb_cold	1807	ecb_noinline ecb_cold
		1808	static void
1101	ev_printerr (const char *msg)	1809	ev_printerr (const char *msg)
1102	{	1810	{
1103	write (STDERR_FILENO, msg, strlen (msg));	1811	write (STDERR_FILENO, msg, strlen (msg));
1104	}	1812	}
1105	#endif	1813	#endif
1106		1814
1107	static void (*syserr_cb)(const char *msg) EV_THROW;	1815	static void (*syserr_cb)(const char *msg) EV_NOEXCEPT;
1108		1816
1109	void ecb_cold	1817	ecb_cold
		1818	void
1110	ev_set_syserr_cb (void (*cb)(const char *msg)) EV_THROW	1819	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
1111	{	1820	{
1112	syserr_cb = cb;	1821	syserr_cb = cb;
1113	}	1822	}
1114		1823
1115	static void noinline ecb_cold	1824	ecb_noinline ecb_cold
		1825	static void
1116	ev_syserr (const char *msg)	1826	ev_syserr (const char *msg)
1117	{	1827	{
1118	if (!msg)	1828	if (!msg)
1119	msg = "(libev) system error";	1829	msg = "(libev) system error";
1120		1830
…		…
1133	abort ();	1843	abort ();
1134	}	1844	}
1135	}	1845	}
1136		1846
1137	static void *	1847	static void *
1138	ev_realloc_emul (void *ptr, long size)	1848	ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
1139	{	1849	{
1140	#if __GLIBC__
1141	return realloc (ptr, size);
1142	#else
1143	/* some systems, notably openbsd and darwin, fail to properly	1850	/* some systems, notably openbsd and darwin, fail to properly
1144	* implement realloc (x, 0) (as required by both ansi c-89 and	1851	* implement realloc (x, 0) (as required by both ansi c-89 and
1145	* the single unix specification, so work around them here.	1852	* the single unix specification, so work around them here.
		1853	* recently, also (at least) fedora and debian started breaking it,
		1854	* despite documenting it otherwise.
1146	*/	1855	*/
1147		1856
1148	if (size)	1857	if (size)
1149	return realloc (ptr, size);	1858	return realloc (ptr, size);
1150		1859
1151	free (ptr);	1860	free (ptr);
1152	return 0;	1861	return 0;
1153	#endif
1154	}	1862	}
1155		1863
1156	static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;	1864	static void *(*alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul;
1157		1865
1158	void ecb_cold	1866	ecb_cold
		1867	void
1159	ev_set_allocator (void *(*cb)(void *ptr, long size)) EV_THROW	1868	ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT
1160	{	1869	{
1161	alloc = cb;	1870	alloc = cb;
1162	}	1871	}
1163		1872
1164	inline_speed void *	1873	inline_speed void *
…		…
1191	typedef struct	1900	typedef struct
1192	{	1901	{
1193	WL head;	1902	WL head;
1194	unsigned char events; /* the events watched for */	1903	unsigned char events; /* the events watched for */
1195	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */	1904	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
1196	unsigned char emask; /* the epoll backend stores the actual kernel mask in here */	1905	unsigned char emask; /* some backends store the actual kernel mask in here */
1197	unsigned char unused;	1906	unsigned char eflags; /* flags field for use by backends */
1198	#if EV_USE_EPOLL	1907	#if EV_USE_EPOLL
1199	unsigned int egen; /* generation counter to counter epoll bugs */	1908	unsigned int egen; /* generation counter to counter epoll bugs */
1200	#endif	1909	#endif
1201	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	1910	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1202	SOCKET handle;	1911	SOCKET handle;
…		…
1266	static int ev_default_loop_ptr;	1975	static int ev_default_loop_ptr;
1267		1976
1268	#endif	1977	#endif
1269		1978
1270	#if EV_FEATURE_API	1979	#if EV_FEATURE_API
1271	# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)	1980	# define EV_RELEASE_CB if (ecb_expect_false (release_cb)) release_cb (EV_A)
1272	# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)	1981	# define EV_ACQUIRE_CB if (ecb_expect_false (acquire_cb)) acquire_cb (EV_A)
1273	# define EV_INVOKE_PENDING invoke_cb (EV_A)	1982	# define EV_INVOKE_PENDING invoke_cb (EV_A)
1274	#else	1983	#else
1275	# define EV_RELEASE_CB (void)0	1984	# define EV_RELEASE_CB (void)0
1276	# define EV_ACQUIRE_CB (void)0	1985	# define EV_ACQUIRE_CB (void)0
1277	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)	1986	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
…		…
1281		1990
1282	/*****************************************************************************/	1991	/*****************************************************************************/
1283		1992
1284	#ifndef EV_HAVE_EV_TIME	1993	#ifndef EV_HAVE_EV_TIME
1285	ev_tstamp	1994	ev_tstamp
1286	ev_time (void) EV_THROW	1995	ev_time (void) EV_NOEXCEPT
1287	{	1996	{
1288	#if EV_USE_REALTIME	1997	#if EV_USE_REALTIME
1289	if (expect_true (have_realtime))	1998	if (ecb_expect_true (have_realtime))
1290	{	1999	{
1291	struct timespec ts;	2000	struct timespec ts;
1292	clock_gettime (CLOCK_REALTIME, &ts);	2001	clock_gettime (CLOCK_REALTIME, &ts);
1293	return ts.tv_sec + ts.tv_nsec * 1e-9;	2002	return EV_TS_GET (ts);
1294	}	2003	}
1295	#endif	2004	#endif
1296		2005
1297	struct timeval tv;	2006	struct timeval tv;
1298	gettimeofday (&tv, 0);	2007	gettimeofday (&tv, 0);
1299	return tv.tv_sec + tv.tv_usec * 1e-6;	2008	return EV_TV_GET (tv);
1300	}	2009	}
1301	#endif	2010	#endif
1302		2011
1303	inline_size ev_tstamp	2012	inline_size ev_tstamp
1304	get_clock (void)	2013	get_clock (void)
1305	{	2014	{
1306	#if EV_USE_MONOTONIC	2015	#if EV_USE_MONOTONIC
1307	if (expect_true (have_monotonic))	2016	if (ecb_expect_true (have_monotonic))
1308	{	2017	{
1309	struct timespec ts;	2018	struct timespec ts;
1310	clock_gettime (CLOCK_MONOTONIC, &ts);	2019	clock_gettime (CLOCK_MONOTONIC, &ts);
1311	return ts.tv_sec + ts.tv_nsec * 1e-9;	2020	return EV_TS_GET (ts);
1312	}	2021	}
1313	#endif	2022	#endif
1314		2023
1315	return ev_time ();	2024	return ev_time ();
1316	}	2025	}
1317		2026
1318	#if EV_MULTIPLICITY	2027	#if EV_MULTIPLICITY
1319	ev_tstamp	2028	ev_tstamp
1320	ev_now (EV_P) EV_THROW	2029	ev_now (EV_P) EV_NOEXCEPT
1321	{	2030	{
1322	return ev_rt_now;	2031	return ev_rt_now;
1323	}	2032	}
1324	#endif	2033	#endif
1325		2034
1326	void	2035	void
1327	ev_sleep (ev_tstamp delay) EV_THROW	2036	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1328	{	2037	{
1329	if (delay > 0.)	2038	if (delay > 0.)
1330	{	2039	{
1331	#if EV_USE_NANOSLEEP	2040	#if EV_USE_NANOSLEEP
1332	struct timespec ts;	2041	struct timespec ts;
1333		2042
1334	EV_TS_SET (ts, delay);	2043	EV_TS_SET (ts, delay);
1335	nanosleep (&ts, 0);	2044	nanosleep (&ts, 0);
1336	#elif defined _WIN32	2045	#elif defined _WIN32
		2046	/* maybe this should round up, as ms is very low resolution */
		2047	/* compared to select (µs) or nanosleep (ns) */
1337	Sleep ((unsigned long)(delay * 1e3));	2048	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
1338	#else	2049	#else
1339	struct timeval tv;	2050	struct timeval tv;
1340		2051
1341	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */	2052	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
1342	/* something not guaranteed by newer posix versions, but guaranteed */	2053	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
1372	}	2083	}
1373		2084
1374	return ncur;	2085	return ncur;
1375	}	2086	}
1376		2087
1377	static void * noinline ecb_cold	2088	ecb_noinline ecb_cold
		2089	static void *
1378	array_realloc (int elem, void *base, int *cur, int cnt)	2090	array_realloc (int elem, void *base, int *cur, int cnt)
1379	{	2091	{
1380	*cur = array_nextsize (elem, *cur, cnt);	2092	*cur = array_nextsize (elem, *cur, cnt);
1381	return ev_realloc (base, elem * *cur);	2093	return ev_realloc (base, elem * *cur);
1382	}	2094	}
1383		2095
		2096	#define array_needsize_noinit(base,offset,count)
		2097
1384	#define array_init_zero(base,count) \	2098	#define array_needsize_zerofill(base,offset,count) \
1385	memset ((void *)(base), 0, sizeof (*(base)) * (count))	2099	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
1386		2100
1387	#define array_needsize(type,base,cur,cnt,init) \	2101	#define array_needsize(type,base,cur,cnt,init) \
1388	if (expect_false ((cnt) > (cur))) \	2102	if (ecb_expect_false ((cnt) > (cur))) \
1389	{ \	2103	{ \
1390	int ecb_unused ocur_ = (cur); \	2104	ecb_unused int ocur_ = (cur); \
1391	(base) = (type *)array_realloc \	2105	(base) = (type *)array_realloc \
1392	(sizeof (type), (base), &(cur), (cnt)); \	2106	(sizeof (type), (base), &(cur), (cnt)); \
1393	init ((base) + (ocur_), (cur) - ocur_); \	2107	init ((base), ocur_, ((cur) - ocur_)); \
1394	}	2108	}
1395		2109
1396	#if 0	2110	#if 0
1397	#define array_slim(type,stem) \	2111	#define array_slim(type,stem) \
1398	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \	2112	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
…		…
1407	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0	2121	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1408		2122
1409	/*****************************************************************************/	2123	/*****************************************************************************/
1410		2124
1411	/* dummy callback for pending events */	2125	/* dummy callback for pending events */
1412	static void noinline	2126	ecb_noinline
		2127	static void
1413	pendingcb (EV_P_ ev_prepare *w, int revents)	2128	pendingcb (EV_P_ ev_prepare *w, int revents)
1414	{	2129	{
1415	}	2130	}
1416		2131
1417	void noinline	2132	ecb_noinline
		2133	void
1418	ev_feed_event (EV_P_ void *w, int revents) EV_THROW	2134	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
1419	{	2135	{
1420	W w_ = (W)w;	2136	W w_ = (W)w;
1421	int pri = ABSPRI (w_);	2137	int pri = ABSPRI (w_);
1422		2138
1423	if (expect_false (w_->pending))	2139	if (ecb_expect_false (w_->pending))
1424	pendings [pri][w_->pending - 1].events |= revents;	2140	pendings [pri][w_->pending - 1].events |= revents;
1425	else	2141	else
1426	{	2142	{
1427	w_->pending = ++pendingcnt [pri];	2143	w_->pending = ++pendingcnt [pri];
1428	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);	2144	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);
1429	pendings [pri][w_->pending - 1].w = w_;	2145	pendings [pri][w_->pending - 1].w = w_;
1430	pendings [pri][w_->pending - 1].events = revents;	2146	pendings [pri][w_->pending - 1].events = revents;
1431	}	2147	}
1432		2148
1433	pendingpri = NUMPRI - 1;	2149	pendingpri = NUMPRI - 1;
1434	}	2150	}
1435		2151
1436	inline_speed void	2152	inline_speed void
1437	feed_reverse (EV_P_ W w)	2153	feed_reverse (EV_P_ W w)
1438	{	2154	{
1439	array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);	2155	array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, array_needsize_noinit);
1440	rfeeds [rfeedcnt++] = w;	2156	rfeeds [rfeedcnt++] = w;
1441	}	2157	}
1442		2158
1443	inline_size void	2159	inline_size void
1444	feed_reverse_done (EV_P_ int revents)	2160	feed_reverse_done (EV_P_ int revents)
…		…
1479	inline_speed void	2195	inline_speed void
1480	fd_event (EV_P_ int fd, int revents)	2196	fd_event (EV_P_ int fd, int revents)
1481	{	2197	{
1482	ANFD *anfd = anfds + fd;	2198	ANFD *anfd = anfds + fd;
1483		2199
1484	if (expect_true (!anfd->reify))	2200	if (ecb_expect_true (!anfd->reify))
1485	fd_event_nocheck (EV_A_ fd, revents);	2201	fd_event_nocheck (EV_A_ fd, revents);
1486	}	2202	}
1487		2203
1488	void	2204	void
1489	ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW	2205	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
1490	{	2206	{
1491	if (fd >= 0 && fd < anfdmax)	2207	if (fd >= 0 && fd < anfdmax)
1492	fd_event_nocheck (EV_A_ fd, revents);	2208	fd_event_nocheck (EV_A_ fd, revents);
1493	}	2209	}
1494		2210
…		…
1531	ev_io *w;	2247	ev_io *w;
1532		2248
1533	unsigned char o_events = anfd->events;	2249	unsigned char o_events = anfd->events;
1534	unsigned char o_reify = anfd->reify;	2250	unsigned char o_reify = anfd->reify;
1535		2251
1536	anfd->reify = 0;	2252	anfd->reify = 0;
1537		2253
1538	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2254	/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
1539	{	2255	{
1540	anfd->events = 0;	2256	anfd->events = 0;
1541		2257
1542	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)	2258	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
1543	anfd->events |= (unsigned char)w->events;	2259	anfd->events |= (unsigned char)w->events;
…		…
1552		2268
1553	fdchangecnt = 0;	2269	fdchangecnt = 0;
1554	}	2270	}
1555		2271
1556	/* something about the given fd changed */	2272	/* something about the given fd changed */
1557	inline_size void	2273	inline_size
		2274	void
1558	fd_change (EV_P_ int fd, int flags)	2275	fd_change (EV_P_ int fd, int flags)
1559	{	2276	{
1560	unsigned char reify = anfds [fd].reify;	2277	unsigned char reify = anfds [fd].reify;
1561	anfds [fd].reify |= flags;	2278	anfds [fd].reify |= flags;
1562		2279
1563	if (expect_true (!reify))	2280	if (ecb_expect_true (!reify))
1564	{	2281	{
1565	++fdchangecnt;	2282	++fdchangecnt;
1566	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);	2283	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
1567	fdchanges [fdchangecnt - 1] = fd;	2284	fdchanges [fdchangecnt - 1] = fd;
1568	}	2285	}
1569	}	2286	}
1570		2287
1571	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */	2288	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
1572	inline_speed void ecb_cold	2289	inline_speed ecb_cold void
1573	fd_kill (EV_P_ int fd)	2290	fd_kill (EV_P_ int fd)
1574	{	2291	{
1575	ev_io *w;	2292	ev_io *w;
1576		2293
1577	while ((w = (ev_io *)anfds [fd].head))	2294	while ((w = (ev_io *)anfds [fd].head))
…		…
1580	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);	2297	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
1581	}	2298	}
1582	}	2299	}
1583		2300
1584	/* check whether the given fd is actually valid, for error recovery */	2301	/* check whether the given fd is actually valid, for error recovery */
1585	inline_size int ecb_cold	2302	inline_size ecb_cold int
1586	fd_valid (int fd)	2303	fd_valid (int fd)
1587	{	2304	{
1588	#ifdef _WIN32	2305	#ifdef _WIN32
1589	return EV_FD_TO_WIN32_HANDLE (fd) != -1;	2306	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
1590	#else	2307	#else
1591	return fcntl (fd, F_GETFD) != -1;	2308	return fcntl (fd, F_GETFD) != -1;
1592	#endif	2309	#endif
1593	}	2310	}
1594		2311
1595	/* called on EBADF to verify fds */	2312	/* called on EBADF to verify fds */
1596	static void noinline ecb_cold	2313	ecb_noinline ecb_cold
		2314	static void
1597	fd_ebadf (EV_P)	2315	fd_ebadf (EV_P)
1598	{	2316	{
1599	int fd;	2317	int fd;
1600		2318
1601	for (fd = 0; fd < anfdmax; ++fd)	2319	for (fd = 0; fd < anfdmax; ++fd)
…		…
1603	if (!fd_valid (fd) && errno == EBADF)	2321	if (!fd_valid (fd) && errno == EBADF)
1604	fd_kill (EV_A_ fd);	2322	fd_kill (EV_A_ fd);
1605	}	2323	}
1606		2324
1607	/* called on ENOMEM in select/poll to kill some fds and retry */	2325	/* called on ENOMEM in select/poll to kill some fds and retry */
1608	static void noinline ecb_cold	2326	ecb_noinline ecb_cold
		2327	static void
1609	fd_enomem (EV_P)	2328	fd_enomem (EV_P)
1610	{	2329	{
1611	int fd;	2330	int fd;
1612		2331
1613	for (fd = anfdmax; fd--; )	2332	for (fd = anfdmax; fd--; )
…		…
1617	break;	2336	break;
1618	}	2337	}
1619	}	2338	}
1620		2339
1621	/* usually called after fork if backend needs to re-arm all fds from scratch */	2340	/* usually called after fork if backend needs to re-arm all fds from scratch */
1622	static void noinline	2341	ecb_noinline
		2342	static void
1623	fd_rearm_all (EV_P)	2343	fd_rearm_all (EV_P)
1624	{	2344	{
1625	int fd;	2345	int fd;
1626		2346
1627	for (fd = 0; fd < anfdmax; ++fd)	2347	for (fd = 0; fd < anfdmax; ++fd)
…		…
1680	ev_tstamp minat;	2400	ev_tstamp minat;
1681	ANHE *minpos;	2401	ANHE *minpos;
1682	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;	2402	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
1683		2403
1684	/* find minimum child */	2404	/* find minimum child */
1685	if (expect_true (pos + DHEAP - 1 < E))	2405	if (ecb_expect_true (pos + DHEAP - 1 < E))
1686	{	2406	{
1687	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2407	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
1688	if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2408	if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1689	if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2409	if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1690	if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2410	if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1691	}	2411	}
1692	else if (pos < E)	2412	else if (pos < E)
1693	{	2413	{
1694	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2414	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
1695	if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2415	if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1696	if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2416	if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1697	if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2417	if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1698	}	2418	}
1699	else	2419	else
1700	break;	2420	break;
1701		2421
1702	if (ANHE_at (he) <= minat)	2422	if (ANHE_at (he) <= minat)
…		…
1710		2430
1711	heap [k] = he;	2431	heap [k] = he;
1712	ev_active (ANHE_w (he)) = k;	2432	ev_active (ANHE_w (he)) = k;
1713	}	2433	}
1714		2434
1715	#else /* 4HEAP */	2435	#else /* not 4HEAP */
1716		2436
1717	#define HEAP0 1	2437	#define HEAP0 1
1718	#define HPARENT(k) ((k) >> 1)	2438	#define HPARENT(k) ((k) >> 1)
1719	#define UPHEAP_DONE(p,k) (!(p))	2439	#define UPHEAP_DONE(p,k) (!(p))
1720		2440
…		…
1808		2528
1809	/*****************************************************************************/	2529	/*****************************************************************************/
1810		2530
1811	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2531	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
1812		2532
1813	static void noinline ecb_cold	2533	ecb_noinline ecb_cold
		2534	static void
1814	evpipe_init (EV_P)	2535	evpipe_init (EV_P)
1815	{	2536	{
1816	if (!ev_is_active (&pipe_w))	2537	if (!ev_is_active (&pipe_w))
1817	{	2538	{
		2539	int fds [2];
		2540
1818	# if EV_USE_EVENTFD	2541	# if EV_USE_EVENTFD
		2542	fds [0] = -1;
1819	evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);	2543	fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
1820	if (evfd < 0 && errno == EINVAL)	2544	if (fds [1] < 0 && errno == EINVAL)
1821	evfd = eventfd (0, 0);	2545	fds [1] = eventfd (0, 0);
1822		2546
1823	if (evfd >= 0)	2547	if (fds [1] < 0)
1824	{
1825	evpipe [0] = -1;
1826	fd_intern (evfd); /* doing it twice doesn't hurt */
1827	ev_io_set (&pipe_w, evfd, EV_READ);
1828	}
1829	else
1830	# endif	2548	# endif
1831	{	2549	{
1832	while (pipe (evpipe))	2550	while (pipe (fds))
1833	ev_syserr ("(libev) error creating signal/async pipe");	2551	ev_syserr ("(libev) error creating signal/async pipe");
1834		2552
1835	fd_intern (evpipe [0]);	2553	fd_intern (fds [0]);
1836	fd_intern (evpipe [1]);
1837	ev_io_set (&pipe_w, evpipe [0], EV_READ);
1838	}	2554	}
1839		2555
		2556	evpipe [0] = fds [0];
		2557
		2558	if (evpipe [1] < 0)
		2559	evpipe [1] = fds [1]; /* first call, set write fd */
		2560	else
		2561	{
		2562	/* on subsequent calls, do not change evpipe [1] */
		2563	/* so that evpipe_write can always rely on its value. */
		2564	/* this branch does not do anything sensible on windows, */
		2565	/* so must not be executed on windows */
		2566
		2567	dup2 (fds [1], evpipe [1]);
		2568	close (fds [1]);
		2569	}
		2570
		2571	fd_intern (evpipe [1]);
		2572
		2573	ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
1840	ev_io_start (EV_A_ &pipe_w);	2574	ev_io_start (EV_A_ &pipe_w);
1841	ev_unref (EV_A); /* watcher should not keep loop alive */	2575	ev_unref (EV_A); /* watcher should not keep loop alive */
1842	}	2576	}
1843	}	2577	}
1844		2578
1845	inline_speed void	2579	inline_speed void
1846	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	2580	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1847	{	2581	{
1848	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */	2582	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
1849		2583
1850	if (expect_true (*flag))	2584	if (ecb_expect_true (*flag))
1851	return;	2585	return;
1852		2586
1853	*flag = 1;	2587	*flag = 1;
1854
1855	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */	2588	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
1856		2589
1857	pipe_write_skipped = 1;	2590	pipe_write_skipped = 1;
1858		2591
1859	ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */	2592	ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
1860		2593
1861	if (pipe_write_wanted)	2594	if (pipe_write_wanted)
1862	{	2595	{
1863	int old_errno;	2596	int old_errno;
1864		2597
1865	pipe_write_skipped = 0; /* just an optimisation, no fence needed */	2598	pipe_write_skipped = 0;
		2599	ECB_MEMORY_FENCE_RELEASE;
1866		2600
1867	old_errno = errno; /* save errno because write will clobber it */	2601	old_errno = errno; /* save errno because write will clobber it */
1868		2602
1869	#if EV_USE_EVENTFD	2603	#if EV_USE_EVENTFD
1870	if (evfd >= 0)	2604	if (evpipe [0] < 0)
1871	{	2605	{
1872	uint64_t counter = 1;	2606	uint64_t counter = 1;
1873	write (evfd, &counter, sizeof (uint64_t));	2607	write (evpipe [1], &counter, sizeof (uint64_t));
1874	}	2608	}
1875	else	2609	else
1876	#endif	2610	#endif
1877	{	2611	{
1878	#ifdef _WIN32	2612	#ifdef _WIN32
1879	WSABUF buf;	2613	WSABUF buf;
1880	DWORD sent;	2614	DWORD sent;
1881	buf.buf = &buf;	2615	buf.buf = (char *)&buf;
1882	buf.len = 1;	2616	buf.len = 1;
1883	WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);	2617	WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
1884	#else	2618	#else
1885	write (evpipe [1], &(evpipe [1]), 1);	2619	write (evpipe [1], &(evpipe [1]), 1);
1886	#endif	2620	#endif
…		…
1898	int i;	2632	int i;
1899		2633
1900	if (revents & EV_READ)	2634	if (revents & EV_READ)
1901	{	2635	{
1902	#if EV_USE_EVENTFD	2636	#if EV_USE_EVENTFD
1903	if (evfd >= 0)	2637	if (evpipe [0] < 0)
1904	{	2638	{
1905	uint64_t counter;	2639	uint64_t counter;
1906	read (evfd, &counter, sizeof (uint64_t));	2640	read (evpipe [1], &counter, sizeof (uint64_t));
1907	}	2641	}
1908	else	2642	else
1909	#endif	2643	#endif
1910	{	2644	{
1911	char dummy[4];	2645	char dummy[4];
1912	#ifdef _WIN32	2646	#ifdef _WIN32
1913	WSABUF buf;	2647	WSABUF buf;
1914	DWORD recvd;	2648	DWORD recvd;
		2649	DWORD flags = 0;
1915	buf.buf = dummy;	2650	buf.buf = dummy;
1916	buf.len = sizeof (dummy);	2651	buf.len = sizeof (dummy);
1917	WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, 0, 0, 0);	2652	WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, &flags, 0, 0);
1918	#else	2653	#else
1919	read (evpipe [0], &dummy, sizeof (dummy));	2654	read (evpipe [0], &dummy, sizeof (dummy));
1920	#endif	2655	#endif
1921	}	2656	}
1922	}	2657	}
…		…
1928	#if EV_SIGNAL_ENABLE	2663	#if EV_SIGNAL_ENABLE
1929	if (sig_pending)	2664	if (sig_pending)
1930	{	2665	{
1931	sig_pending = 0;	2666	sig_pending = 0;
1932		2667
1933	ECB_MEMORY_FENCE_RELEASE;	2668	ECB_MEMORY_FENCE;
1934		2669
1935	for (i = EV_NSIG - 1; i--; )	2670	for (i = EV_NSIG - 1; i--; )
1936	if (expect_false (signals [i].pending))	2671	if (ecb_expect_false (signals [i].pending))
1937	ev_feed_signal_event (EV_A_ i + 1);	2672	ev_feed_signal_event (EV_A_ i + 1);
1938	}	2673	}
1939	#endif	2674	#endif
1940		2675
1941	#if EV_ASYNC_ENABLE	2676	#if EV_ASYNC_ENABLE
1942	if (async_pending)	2677	if (async_pending)
1943	{	2678	{
1944	async_pending = 0;	2679	async_pending = 0;
1945		2680
1946	ECB_MEMORY_FENCE_RELEASE;	2681	ECB_MEMORY_FENCE;
1947		2682
1948	for (i = asynccnt; i--; )	2683	for (i = asynccnt; i--; )
1949	if (asyncs [i]->sent)	2684	if (asyncs [i]->sent)
1950	{	2685	{
1951	asyncs [i]->sent = 0;	2686	asyncs [i]->sent = 0;
		2687	ECB_MEMORY_FENCE_RELEASE;
1952	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);	2688	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
1953	}	2689	}
1954	}	2690	}
1955	#endif	2691	#endif
1956	}	2692	}
1957		2693
1958	/*****************************************************************************/	2694	/*****************************************************************************/
1959		2695
1960	void	2696	void
1961	ev_feed_signal (int signum) EV_THROW	2697	ev_feed_signal (int signum) EV_NOEXCEPT
1962	{	2698	{
1963	#if EV_MULTIPLICITY	2699	#if EV_MULTIPLICITY
		2700	EV_P;
		2701	ECB_MEMORY_FENCE_ACQUIRE;
1964	EV_P = signals [signum - 1].loop;	2702	EV_A = signals [signum - 1].loop;
1965		2703
1966	if (!EV_A)	2704	if (!EV_A)
1967	return;	2705	return;
1968	#endif	2706	#endif
1969		2707
1970	if (!ev_active (&pipe_w))
1971	return;
1972
1973	signals [signum - 1].pending = 1;	2708	signals [signum - 1].pending = 1;
1974	evpipe_write (EV_A_ &sig_pending);	2709	evpipe_write (EV_A_ &sig_pending);
1975	}	2710	}
1976		2711
1977	static void	2712	static void
…		…
1982	#endif	2717	#endif
1983		2718
1984	ev_feed_signal (signum);	2719	ev_feed_signal (signum);
1985	}	2720	}
1986		2721
1987	void noinline	2722	ecb_noinline
		2723	void
1988	ev_feed_signal_event (EV_P_ int signum) EV_THROW	2724	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
1989	{	2725	{
1990	WL w;	2726	WL w;
1991		2727
1992	if (expect_false (signum <= 0 || signum > EV_NSIG))	2728	if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
1993	return;	2729	return;
1994		2730
1995	--signum;	2731	--signum;
1996		2732
1997	#if EV_MULTIPLICITY	2733	#if EV_MULTIPLICITY
1998	/* it is permissible to try to feed a signal to the wrong loop */	2734	/* it is permissible to try to feed a signal to the wrong loop */
1999	/* or, likely more useful, feeding a signal nobody is waiting for */	2735	/* or, likely more useful, feeding a signal nobody is waiting for */
2000		2736
2001	if (expect_false (signals [signum].loop != EV_A))	2737	if (ecb_expect_false (signals [signum].loop != EV_A))
2002	return;	2738	return;
2003	#endif	2739	#endif
2004		2740
2005	signals [signum].pending = 0;	2741	signals [signum].pending = 0;
		2742	ECB_MEMORY_FENCE_RELEASE;
2006		2743
2007	for (w = signals [signum].head; w; w = w->next)	2744	for (w = signals [signum].head; w; w = w->next)
2008	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);	2745	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
2009	}	2746	}
2010		2747
…		…
2101	# include "ev_kqueue.c"	2838	# include "ev_kqueue.c"
2102	#endif	2839	#endif
2103	#if EV_USE_EPOLL	2840	#if EV_USE_EPOLL
2104	# include "ev_epoll.c"	2841	# include "ev_epoll.c"
2105	#endif	2842	#endif
		2843	#if EV_USE_LINUXAIO
		2844	# include "ev_linuxaio.c"
		2845	#endif
		2846	#if EV_USE_IOURING
		2847	# include "ev_iouring.c"
		2848	#endif
2106	#if EV_USE_POLL	2849	#if EV_USE_POLL
2107	# include "ev_poll.c"	2850	# include "ev_poll.c"
2108	#endif	2851	#endif
2109	#if EV_USE_SELECT	2852	#if EV_USE_SELECT
2110	# include "ev_select.c"	2853	# include "ev_select.c"
2111	#endif	2854	#endif
2112		2855
2113	int ecb_cold	2856	ecb_cold int
2114	ev_version_major (void) EV_THROW	2857	ev_version_major (void) EV_NOEXCEPT
2115	{	2858	{
2116	return EV_VERSION_MAJOR;	2859	return EV_VERSION_MAJOR;
2117	}	2860	}
2118		2861
2119	int ecb_cold	2862	ecb_cold int
2120	ev_version_minor (void) EV_THROW	2863	ev_version_minor (void) EV_NOEXCEPT
2121	{	2864	{
2122	return EV_VERSION_MINOR;	2865	return EV_VERSION_MINOR;
2123	}	2866	}
2124		2867
2125	/* return true if we are running with elevated privileges and should ignore env variables */	2868	/* return true if we are running with elevated privileges and should ignore env variables */
2126	int inline_size ecb_cold	2869	inline_size ecb_cold int
2127	enable_secure (void)	2870	enable_secure (void)
2128	{	2871	{
2129	#ifdef _WIN32	2872	#ifdef _WIN32
2130	return 0;	2873	return 0;
2131	#else	2874	#else
2132	return getuid () != geteuid ()	2875	return getuid () != geteuid ()
2133	|| getgid () != getegid ();	2876	|| getgid () != getegid ();
2134	#endif	2877	#endif
2135	}	2878	}
2136		2879
2137	unsigned int ecb_cold	2880	ecb_cold
		2881	unsigned int
2138	ev_supported_backends (void) EV_THROW	2882	ev_supported_backends (void) EV_NOEXCEPT
2139	{	2883	{
2140	unsigned int flags = 0;	2884	unsigned int flags = 0;
2141		2885
2142	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	2886	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2143	if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;	2887	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2144	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	2888	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
		2889	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;
		2890	if (EV_USE_IOURING ) flags |= EVBACKEND_IOURING;
2145	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	2891	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2146	if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;	2892	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
2147		2893
2148	return flags;	2894	return flags;
2149	}	2895	}
2150		2896
2151	unsigned int ecb_cold	2897	ecb_cold
		2898	unsigned int
2152	ev_recommended_backends (void) EV_THROW	2899	ev_recommended_backends (void) EV_NOEXCEPT
2153	{	2900	{
2154	unsigned int flags = ev_supported_backends ();	2901	unsigned int flags = ev_supported_backends ();
2155		2902
2156	#ifndef __NetBSD__	2903	#ifndef __NetBSD__
2157	/* kqueue is borked on everything but netbsd apparently */	2904	/* kqueue is borked on everything but netbsd apparently */
…		…
2165	#endif	2912	#endif
2166	#ifdef __FreeBSD__	2913	#ifdef __FreeBSD__
2167	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */	2914	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
2168	#endif	2915	#endif
2169		2916
		2917	/* TODO: linuxaio is very experimental */
		2918	#if !EV_RECOMMEND_LINUXAIO
		2919	flags &= ~EVBACKEND_LINUXAIO;
		2920	#endif
		2921	/* TODO: linuxaio is super experimental */
		2922	#if !EV_RECOMMEND_IOURING
		2923	flags &= ~EVBACKEND_IOURING;
		2924	#endif
		2925
2170	return flags;	2926	return flags;
2171	}	2927	}
2172		2928
2173	unsigned int ecb_cold	2929	ecb_cold
		2930	unsigned int
2174	ev_embeddable_backends (void) EV_THROW	2931	ev_embeddable_backends (void) EV_NOEXCEPT
2175	{	2932	{
2176	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	2933	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2177		2934
2178	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	2935	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2179	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	2936	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2180	flags &= ~EVBACKEND_EPOLL;	2937	flags &= ~EVBACKEND_EPOLL;
2181		2938
		2939	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
		2940
		2941	/* EVBACKEND_IOURING is practically embeddable, but the current implementation is not
		2942	* because our backend_fd is the epoll fd we need as fallback.
		2943	* if the kernel ever is fixed, this might change...
		2944	*/
		2945
2182	return flags;	2946	return flags;
2183	}	2947	}
2184		2948
2185	unsigned int	2949	unsigned int
2186	ev_backend (EV_P) EV_THROW	2950	ev_backend (EV_P) EV_NOEXCEPT
2187	{	2951	{
2188	return backend;	2952	return backend;
2189	}	2953	}
2190		2954
2191	#if EV_FEATURE_API	2955	#if EV_FEATURE_API
2192	unsigned int	2956	unsigned int
2193	ev_iteration (EV_P) EV_THROW	2957	ev_iteration (EV_P) EV_NOEXCEPT
2194	{	2958	{
2195	return loop_count;	2959	return loop_count;
2196	}	2960	}
2197		2961
2198	unsigned int	2962	unsigned int
2199	ev_depth (EV_P) EV_THROW	2963	ev_depth (EV_P) EV_NOEXCEPT
2200	{	2964	{
2201	return loop_depth;	2965	return loop_depth;
2202	}	2966	}
2203		2967
2204	void	2968	void
2205	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	2969	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2206	{	2970	{
2207	io_blocktime = interval;	2971	io_blocktime = interval;
2208	}	2972	}
2209		2973
2210	void	2974	void
2211	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	2975	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2212	{	2976	{
2213	timeout_blocktime = interval;	2977	timeout_blocktime = interval;
2214	}	2978	}
2215		2979
2216	void	2980	void
2217	ev_set_userdata (EV_P_ void *data) EV_THROW	2981	ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT
2218	{	2982	{
2219	userdata = data;	2983	userdata = data;
2220	}	2984	}
2221		2985
2222	void *	2986	void *
2223	ev_userdata (EV_P) EV_THROW	2987	ev_userdata (EV_P) EV_NOEXCEPT
2224	{	2988	{
2225	return userdata;	2989	return userdata;
2226	}	2990	}
2227		2991
2228	void	2992	void
2229	ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW	2993	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT
2230	{	2994	{
2231	invoke_cb = invoke_pending_cb;	2995	invoke_cb = invoke_pending_cb;
2232	}	2996	}
2233		2997
2234	void	2998	void
2235	ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW	2999	ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT
2236	{	3000	{
2237	release_cb = release;	3001	release_cb = release;
2238	acquire_cb = acquire;	3002	acquire_cb = acquire;
2239	}	3003	}
2240	#endif	3004	#endif
2241		3005
2242	/* initialise a loop structure, must be zero-initialised */	3006	/* initialise a loop structure, must be zero-initialised */
2243	static void noinline ecb_cold	3007	ecb_noinline ecb_cold
		3008	static void
2244	loop_init (EV_P_ unsigned int flags) EV_THROW	3009	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2245	{	3010	{
2246	if (!backend)	3011	if (!backend)
2247	{	3012	{
2248	origflags = flags;	3013	origflags = flags;
2249		3014
…		…
2294	#if EV_ASYNC_ENABLE	3059	#if EV_ASYNC_ENABLE
2295	async_pending = 0;	3060	async_pending = 0;
2296	#endif	3061	#endif
2297	pipe_write_skipped = 0;	3062	pipe_write_skipped = 0;
2298	pipe_write_wanted = 0;	3063	pipe_write_wanted = 0;
		3064	evpipe [0] = -1;
		3065	evpipe [1] = -1;
2299	#if EV_USE_INOTIFY	3066	#if EV_USE_INOTIFY
2300	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3067	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2301	#endif	3068	#endif
2302	#if EV_USE_SIGNALFD	3069	#if EV_USE_SIGNALFD
2303	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3070	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
…		…
2305		3072
2306	if (!(flags & EVBACKEND_MASK))	3073	if (!(flags & EVBACKEND_MASK))
2307	flags |= ev_recommended_backends ();	3074	flags |= ev_recommended_backends ();
2308		3075
2309	#if EV_USE_IOCP	3076	#if EV_USE_IOCP
2310	if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);	3077	if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);
2311	#endif	3078	#endif
2312	#if EV_USE_PORT	3079	#if EV_USE_PORT
2313	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	3080	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2314	#endif	3081	#endif
2315	#if EV_USE_KQUEUE	3082	#if EV_USE_KQUEUE
2316	if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);	3083	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
		3084	#endif
		3085	#if EV_USE_IOURING
		3086	if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
		3087	#endif
		3088	#if EV_USE_LINUXAIO
		3089	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2317	#endif	3090	#endif
2318	#if EV_USE_EPOLL	3091	#if EV_USE_EPOLL
2319	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);	3092	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
2320	#endif	3093	#endif
2321	#if EV_USE_POLL	3094	#if EV_USE_POLL
2322	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);	3095	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
2323	#endif	3096	#endif
2324	#if EV_USE_SELECT	3097	#if EV_USE_SELECT
2325	if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);	3098	if (!backend && (flags & EVBACKEND_SELECT )) backend = select_init (EV_A_ flags);
2326	#endif	3099	#endif
2327		3100
2328	ev_prepare_init (&pending_w, pendingcb);	3101	ev_prepare_init (&pending_w, pendingcb);
2329		3102
2330	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3103	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
…		…
2333	#endif	3106	#endif
2334	}	3107	}
2335	}	3108	}
2336		3109
2337	/* free up a loop structure */	3110	/* free up a loop structure */
2338	void ecb_cold	3111	ecb_cold
		3112	void
2339	ev_loop_destroy (EV_P)	3113	ev_loop_destroy (EV_P)
2340	{	3114	{
2341	int i;	3115	int i;
2342		3116
2343	#if EV_MULTIPLICITY	3117	#if EV_MULTIPLICITY
…		…
2346	return;	3120	return;
2347	#endif	3121	#endif
2348		3122
2349	#if EV_CLEANUP_ENABLE	3123	#if EV_CLEANUP_ENABLE
2350	/* queue cleanup watchers (and execute them) */	3124	/* queue cleanup watchers (and execute them) */
2351	if (expect_false (cleanupcnt))	3125	if (ecb_expect_false (cleanupcnt))
2352	{	3126	{
2353	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);	3127	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
2354	EV_INVOKE_PENDING;	3128	EV_INVOKE_PENDING;
2355	}	3129	}
2356	#endif	3130	#endif
2357		3131
2358	#if EV_CHILD_ENABLE	3132	#if EV_CHILD_ENABLE
2359	if (ev_is_active (&childev))	3133	if (ev_is_default_loop (EV_A) && ev_is_active (&childev))
2360	{	3134	{
2361	ev_ref (EV_A); /* child watcher */	3135	ev_ref (EV_A); /* child watcher */
2362	ev_signal_stop (EV_A_ &childev);	3136	ev_signal_stop (EV_A_ &childev);
2363	}	3137	}
2364	#endif	3138	#endif
…		…
2366	if (ev_is_active (&pipe_w))	3140	if (ev_is_active (&pipe_w))
2367	{	3141	{
2368	/*ev_ref (EV_A);*/	3142	/*ev_ref (EV_A);*/
2369	/*ev_io_stop (EV_A_ &pipe_w);*/	3143	/*ev_io_stop (EV_A_ &pipe_w);*/
2370		3144
2371	#if EV_USE_EVENTFD
2372	if (evfd >= 0)
2373	close (evfd);
2374	#endif
2375
2376	if (evpipe [0] >= 0)
2377	{
2378	EV_WIN32_CLOSE_FD (evpipe [0]);	3145	if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
2379	EV_WIN32_CLOSE_FD (evpipe [1]);	3146	if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
2380	}
2381	}	3147	}
2382		3148
2383	#if EV_USE_SIGNALFD	3149	#if EV_USE_SIGNALFD
2384	if (ev_is_active (&sigfd_w))	3150	if (ev_is_active (&sigfd_w))
2385	close (sigfd);	3151	close (sigfd);
…		…
2392		3158
2393	if (backend_fd >= 0)	3159	if (backend_fd >= 0)
2394	close (backend_fd);	3160	close (backend_fd);
2395		3161
2396	#if EV_USE_IOCP	3162	#if EV_USE_IOCP
2397	if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);	3163	if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);
2398	#endif	3164	#endif
2399	#if EV_USE_PORT	3165	#if EV_USE_PORT
2400	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3166	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
2401	#endif	3167	#endif
2402	#if EV_USE_KQUEUE	3168	#if EV_USE_KQUEUE
2403	if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);	3169	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
		3170	#endif
		3171	#if EV_USE_IOURING
		3172	if (backend == EVBACKEND_IOURING ) iouring_destroy (EV_A);
		3173	#endif
		3174	#if EV_USE_LINUXAIO
		3175	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
2404	#endif	3176	#endif
2405	#if EV_USE_EPOLL	3177	#if EV_USE_EPOLL
2406	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);	3178	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
2407	#endif	3179	#endif
2408	#if EV_USE_POLL	3180	#if EV_USE_POLL
2409	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);	3181	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
2410	#endif	3182	#endif
2411	#if EV_USE_SELECT	3183	#if EV_USE_SELECT
2412	if (backend == EVBACKEND_SELECT) select_destroy (EV_A);	3184	if (backend == EVBACKEND_SELECT ) select_destroy (EV_A);
2413	#endif	3185	#endif
2414		3186
2415	for (i = NUMPRI; i--; )	3187	for (i = NUMPRI; i--; )
2416	{	3188	{
2417	array_free (pending, [i]);	3189	array_free (pending, [i]);
…		…
2459		3231
2460	inline_size void	3232	inline_size void
2461	loop_fork (EV_P)	3233	loop_fork (EV_P)
2462	{	3234	{
2463	#if EV_USE_PORT	3235	#if EV_USE_PORT
2464	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3236	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
2465	#endif	3237	#endif
2466	#if EV_USE_KQUEUE	3238	#if EV_USE_KQUEUE
2467	if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);	3239	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
		3240	#endif
		3241	#if EV_USE_IOURING
		3242	if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
		3243	#endif
		3244	#if EV_USE_LINUXAIO
		3245	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
2468	#endif	3246	#endif
2469	#if EV_USE_EPOLL	3247	#if EV_USE_EPOLL
2470	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3248	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
2471	#endif	3249	#endif
2472	#if EV_USE_INOTIFY	3250	#if EV_USE_INOTIFY
2473	infy_fork (EV_A);	3251	infy_fork (EV_A);
2474	#endif	3252	#endif
2475		3253
		3254	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2476	if (ev_is_active (&pipe_w))	3255	if (ev_is_active (&pipe_w) && postfork != 2)
2477	{	3256	{
2478	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3257	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2479		3258
2480	ev_ref (EV_A);	3259	ev_ref (EV_A);
2481	ev_io_stop (EV_A_ &pipe_w);	3260	ev_io_stop (EV_A_ &pipe_w);
2482		3261
2483	#if EV_USE_EVENTFD
2484	if (evfd >= 0)
2485	close (evfd);
2486	#endif
2487
2488	if (evpipe [0] >= 0)	3262	if (evpipe [0] >= 0)
2489	{
2490	EV_WIN32_CLOSE_FD (evpipe [0]);	3263	EV_WIN32_CLOSE_FD (evpipe [0]);
2491	EV_WIN32_CLOSE_FD (evpipe [1]);
2492	}
2493		3264
2494	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2495	evpipe_init (EV_A);	3265	evpipe_init (EV_A);
2496	/* now iterate over everything, in case we missed something */	3266	/* iterate over everything, in case we missed something before */
2497	pipecb (EV_A_ &pipe_w, EV_READ);	3267	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2498	#endif
2499	}	3268	}
		3269	#endif
2500		3270
2501	postfork = 0;	3271	postfork = 0;
2502	}	3272	}
2503		3273
2504	#if EV_MULTIPLICITY	3274	#if EV_MULTIPLICITY
2505		3275
		3276	ecb_cold
2506	struct ev_loop * ecb_cold	3277	struct ev_loop *
2507	ev_loop_new (unsigned int flags) EV_THROW	3278	ev_loop_new (unsigned int flags) EV_NOEXCEPT
2508	{	3279	{
2509	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));	3280	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2510		3281
2511	memset (EV_A, 0, sizeof (struct ev_loop));	3282	memset (EV_A, 0, sizeof (struct ev_loop));
2512	loop_init (EV_A_ flags);	3283	loop_init (EV_A_ flags);
…		…
2519	}	3290	}
2520		3291
2521	#endif /* multiplicity */	3292	#endif /* multiplicity */
2522		3293
2523	#if EV_VERIFY	3294	#if EV_VERIFY
2524	static void noinline ecb_cold	3295	ecb_noinline ecb_cold
		3296	static void
2525	verify_watcher (EV_P_ W w)	3297	verify_watcher (EV_P_ W w)
2526	{	3298	{
2527	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3299	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
2528		3300
2529	if (w->pending)	3301	if (w->pending)
2530	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3302	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
2531	}	3303	}
2532		3304
2533	static void noinline ecb_cold	3305	ecb_noinline ecb_cold
		3306	static void
2534	verify_heap (EV_P_ ANHE *heap, int N)	3307	verify_heap (EV_P_ ANHE *heap, int N)
2535	{	3308	{
2536	int i;	3309	int i;
2537		3310
2538	for (i = HEAP0; i < N + HEAP0; ++i)	3311	for (i = HEAP0; i < N + HEAP0; ++i)
…		…
2543		3316
2544	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3317	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
2545	}	3318	}
2546	}	3319	}
2547		3320
2548	static void noinline ecb_cold	3321	ecb_noinline ecb_cold
		3322	static void
2549	array_verify (EV_P_ W *ws, int cnt)	3323	array_verify (EV_P_ W *ws, int cnt)
2550	{	3324	{
2551	while (cnt--)	3325	while (cnt--)
2552	{	3326	{
2553	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));	3327	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
…		…
2556	}	3330	}
2557	#endif	3331	#endif
2558		3332
2559	#if EV_FEATURE_API	3333	#if EV_FEATURE_API
2560	void ecb_cold	3334	void ecb_cold
2561	ev_verify (EV_P) EV_THROW	3335	ev_verify (EV_P) EV_NOEXCEPT
2562	{	3336	{
2563	#if EV_VERIFY	3337	#if EV_VERIFY
2564	int i;	3338	int i;
2565	WL w, w2;	3339	WL w, w2;
2566		3340
…		…
2642	#endif	3416	#endif
2643	}	3417	}
2644	#endif	3418	#endif
2645		3419
2646	#if EV_MULTIPLICITY	3420	#if EV_MULTIPLICITY
		3421	ecb_cold
2647	struct ev_loop * ecb_cold	3422	struct ev_loop *
2648	#else	3423	#else
2649	int	3424	int
2650	#endif	3425	#endif
2651	ev_default_loop (unsigned int flags) EV_THROW	3426	ev_default_loop (unsigned int flags) EV_NOEXCEPT
2652	{	3427	{
2653	if (!ev_default_loop_ptr)	3428	if (!ev_default_loop_ptr)
2654	{	3429	{
2655	#if EV_MULTIPLICITY	3430	#if EV_MULTIPLICITY
2656	EV_P = ev_default_loop_ptr = &default_loop_struct;	3431	EV_P = ev_default_loop_ptr = &default_loop_struct;
…		…
2675		3450
2676	return ev_default_loop_ptr;	3451	return ev_default_loop_ptr;
2677	}	3452	}
2678		3453
2679	void	3454	void
2680	ev_loop_fork (EV_P) EV_THROW	3455	ev_loop_fork (EV_P) EV_NOEXCEPT
2681	{	3456	{
2682	postfork = 1; /* must be in line with ev_default_fork */	3457	postfork = 1;
2683	}	3458	}
2684		3459
2685	/*****************************************************************************/	3460	/*****************************************************************************/
2686		3461
2687	void	3462	void
…		…
2689	{	3464	{
2690	EV_CB_INVOKE ((W)w, revents);	3465	EV_CB_INVOKE ((W)w, revents);
2691	}	3466	}
2692		3467
2693	unsigned int	3468	unsigned int
2694	ev_pending_count (EV_P) EV_THROW	3469	ev_pending_count (EV_P) EV_NOEXCEPT
2695	{	3470	{
2696	int pri;	3471	int pri;
2697	unsigned int count = 0;	3472	unsigned int count = 0;
2698		3473
2699	for (pri = NUMPRI; pri--; )	3474	for (pri = NUMPRI; pri--; )
2700	count += pendingcnt [pri];	3475	count += pendingcnt [pri];
2701		3476
2702	return count;	3477	return count;
2703	}	3478	}
2704		3479
2705	void noinline	3480	ecb_noinline
		3481	void
2706	ev_invoke_pending (EV_P)	3482	ev_invoke_pending (EV_P)
2707	{	3483	{
2708	for (pendingpri = NUMPRI; pendingpri--; ) /* pendingpri is modified during the loop */	3484	pendingpri = NUMPRI;
		3485
		3486	do
		3487	{
		3488	--pendingpri;
		3489
		3490	/* pendingpri possibly gets modified in the inner loop */
2709	while (pendingcnt [pendingpri])	3491	while (pendingcnt [pendingpri])
2710	{	3492	{
2711	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];	3493	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2712		3494
2713	p->w->pending = 0;	3495	p->w->pending = 0;
2714	EV_CB_INVOKE (p->w, p->events);	3496	EV_CB_INVOKE (p->w, p->events);
2715	EV_FREQUENT_CHECK;	3497	EV_FREQUENT_CHECK;
2716	}	3498	}
		3499	}
		3500	while (pendingpri);
2717	}	3501	}
2718		3502
2719	#if EV_IDLE_ENABLE	3503	#if EV_IDLE_ENABLE
2720	/* make idle watchers pending. this handles the "call-idle */	3504	/* make idle watchers pending. this handles the "call-idle */
2721	/* only when higher priorities are idle" logic */	3505	/* only when higher priorities are idle" logic */
2722	inline_size void	3506	inline_size void
2723	idle_reify (EV_P)	3507	idle_reify (EV_P)
2724	{	3508	{
2725	if (expect_false (idleall))	3509	if (ecb_expect_false (idleall))
2726	{	3510	{
2727	int pri;	3511	int pri;
2728		3512
2729	for (pri = NUMPRI; pri--; )	3513	for (pri = NUMPRI; pri--; )
2730	{	3514	{
…		…
2779	}	3563	}
2780	}	3564	}
2781		3565
2782	#if EV_PERIODIC_ENABLE	3566	#if EV_PERIODIC_ENABLE
2783		3567
2784	static void noinline	3568	ecb_noinline
		3569	static void
2785	periodic_recalc (EV_P_ ev_periodic *w)	3570	periodic_recalc (EV_P_ ev_periodic *w)
2786	{	3571	{
2787	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3572	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
2788	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);	3573	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
2789		3574
…		…
2791	while (at <= ev_rt_now)	3576	while (at <= ev_rt_now)
2792	{	3577	{
2793	ev_tstamp nat = at + w->interval;	3578	ev_tstamp nat = at + w->interval;
2794		3579
2795	/* when resolution fails us, we use ev_rt_now */	3580	/* when resolution fails us, we use ev_rt_now */
2796	if (expect_false (nat == at))	3581	if (ecb_expect_false (nat == at))
2797	{	3582	{
2798	at = ev_rt_now;	3583	at = ev_rt_now;
2799	break;	3584	break;
2800	}	3585	}
2801		3586
…		…
2811	{	3596	{
2812	EV_FREQUENT_CHECK;	3597	EV_FREQUENT_CHECK;
2813		3598
2814	while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)	3599	while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
2815	{	3600	{
2816	int feed_count = 0;
2817
2818	do	3601	do
2819	{	3602	{
2820	ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);	3603	ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
2821		3604
2822	/*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/	3605	/*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/
…		…
2849	}	3632	}
2850	}	3633	}
2851		3634
2852	/* simply recalculate all periodics */	3635	/* simply recalculate all periodics */
2853	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3636	/* TODO: maybe ensure that at least one event happens when jumping forward? */
2854	static void noinline ecb_cold	3637	ecb_noinline ecb_cold
		3638	static void
2855	periodics_reschedule (EV_P)	3639	periodics_reschedule (EV_P)
2856	{	3640	{
2857	int i;	3641	int i;
2858		3642
2859	/* adjust periodics after time jump */	3643	/* adjust periodics after time jump */
…		…
2872	reheap (periodics, periodiccnt);	3656	reheap (periodics, periodiccnt);
2873	}	3657	}
2874	#endif	3658	#endif
2875		3659
2876	/* adjust all timers by a given offset */	3660	/* adjust all timers by a given offset */
2877	static void noinline ecb_cold	3661	ecb_noinline ecb_cold
		3662	static void
2878	timers_reschedule (EV_P_ ev_tstamp adjust)	3663	timers_reschedule (EV_P_ ev_tstamp adjust)
2879	{	3664	{
2880	int i;	3665	int i;
2881		3666
2882	for (i = 0; i < timercnt; ++i)	3667	for (i = 0; i < timercnt; ++i)
…		…
2891	/* also detect if there was a timejump, and act accordingly */	3676	/* also detect if there was a timejump, and act accordingly */
2892	inline_speed void	3677	inline_speed void
2893	time_update (EV_P_ ev_tstamp max_block)	3678	time_update (EV_P_ ev_tstamp max_block)
2894	{	3679	{
2895	#if EV_USE_MONOTONIC	3680	#if EV_USE_MONOTONIC
2896	if (expect_true (have_monotonic))	3681	if (ecb_expect_true (have_monotonic))
2897	{	3682	{
2898	int i;	3683	int i;
2899	ev_tstamp odiff = rtmn_diff;	3684	ev_tstamp odiff = rtmn_diff;
2900		3685
2901	mn_now = get_clock ();	3686	mn_now = get_clock ();
2902		3687
2903	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */	3688	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
2904	/* interpolate in the meantime */	3689	/* interpolate in the meantime */
2905	if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))	3690	if (ecb_expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
2906	{	3691	{
2907	ev_rt_now = rtmn_diff + mn_now;	3692	ev_rt_now = rtmn_diff + mn_now;
2908	return;	3693	return;
2909	}	3694	}
2910		3695
…		…
2924	ev_tstamp diff;	3709	ev_tstamp diff;
2925	rtmn_diff = ev_rt_now - mn_now;	3710	rtmn_diff = ev_rt_now - mn_now;
2926		3711
2927	diff = odiff - rtmn_diff;	3712	diff = odiff - rtmn_diff;
2928		3713
2929	if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))	3714	if (ecb_expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))
2930	return; /* all is well */	3715	return; /* all is well */
2931		3716
2932	ev_rt_now = ev_time ();	3717	ev_rt_now = ev_time ();
2933	mn_now = get_clock ();	3718	mn_now = get_clock ();
2934	now_floor = mn_now;	3719	now_floor = mn_now;
…		…
2943	else	3728	else
2944	#endif	3729	#endif
2945	{	3730	{
2946	ev_rt_now = ev_time ();	3731	ev_rt_now = ev_time ();
2947		3732
2948	if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))	3733	if (ecb_expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))
2949	{	3734	{
2950	/* adjust timers. this is easy, as the offset is the same for all of them */	3735	/* adjust timers. this is easy, as the offset is the same for all of them */
2951	timers_reschedule (EV_A_ ev_rt_now - mn_now);	3736	timers_reschedule (EV_A_ ev_rt_now - mn_now);
2952	#if EV_PERIODIC_ENABLE	3737	#if EV_PERIODIC_ENABLE
2953	periodics_reschedule (EV_A);	3738	periodics_reschedule (EV_A);
…		…
2976	#if EV_VERIFY >= 2	3761	#if EV_VERIFY >= 2
2977	ev_verify (EV_A);	3762	ev_verify (EV_A);
2978	#endif	3763	#endif
2979		3764
2980	#ifndef _WIN32	3765	#ifndef _WIN32
2981	if (expect_false (curpid)) /* penalise the forking check even more */	3766	if (ecb_expect_false (curpid)) /* penalise the forking check even more */
2982	if (expect_false (getpid () != curpid))	3767	if (ecb_expect_false (getpid () != curpid))
2983	{	3768	{
2984	curpid = getpid ();	3769	curpid = getpid ();
2985	postfork = 1;	3770	postfork = 1;
2986	}	3771	}
2987	#endif	3772	#endif
2988		3773
2989	#if EV_FORK_ENABLE	3774	#if EV_FORK_ENABLE
2990	/* we might have forked, so queue fork handlers */	3775	/* we might have forked, so queue fork handlers */
2991	if (expect_false (postfork))	3776	if (ecb_expect_false (postfork))
2992	if (forkcnt)	3777	if (forkcnt)
2993	{	3778	{
2994	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	3779	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
2995	EV_INVOKE_PENDING;	3780	EV_INVOKE_PENDING;
2996	}	3781	}
2997	#endif	3782	#endif
2998		3783
2999	#if EV_PREPARE_ENABLE	3784	#if EV_PREPARE_ENABLE
3000	/* queue prepare watchers (and execute them) */	3785	/* queue prepare watchers (and execute them) */
3001	if (expect_false (preparecnt))	3786	if (ecb_expect_false (preparecnt))
3002	{	3787	{
3003	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	3788	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3004	EV_INVOKE_PENDING;	3789	EV_INVOKE_PENDING;
3005	}	3790	}
3006	#endif	3791	#endif
3007		3792
3008	if (expect_false (loop_done))	3793	if (ecb_expect_false (loop_done))
3009	break;	3794	break;
3010		3795
3011	/* we might have forked, so reify kernel state if necessary */	3796	/* we might have forked, so reify kernel state if necessary */
3012	if (expect_false (postfork))	3797	if (ecb_expect_false (postfork))
3013	loop_fork (EV_A);	3798	loop_fork (EV_A);
3014		3799
3015	/* update fd-related kernel structures */	3800	/* update fd-related kernel structures */
3016	fd_reify (EV_A);	3801	fd_reify (EV_A);
3017		3802
…		…
3029	/* from now on, we want a pipe-wake-up */	3814	/* from now on, we want a pipe-wake-up */
3030	pipe_write_wanted = 1;	3815	pipe_write_wanted = 1;
3031		3816
3032	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */	3817	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3033		3818
3034	if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))	3819	if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3035	{	3820	{
3036	waittime = MAX_BLOCKTIME;	3821	waittime = MAX_BLOCKTIME;
3037		3822
3038	if (timercnt)	3823	if (timercnt)
3039	{	3824	{
…		…
3048	if (waittime > to) waittime = to;	3833	if (waittime > to) waittime = to;
3049	}	3834	}
3050	#endif	3835	#endif
3051		3836
3052	/* don't let timeouts decrease the waittime below timeout_blocktime */	3837	/* don't let timeouts decrease the waittime below timeout_blocktime */
3053	if (expect_false (waittime < timeout_blocktime))	3838	if (ecb_expect_false (waittime < timeout_blocktime))
3054	waittime = timeout_blocktime;	3839	waittime = timeout_blocktime;
3055		3840
3056	/* at this point, we NEED to wait, so we have to ensure */	3841	/* at this point, we NEED to wait, so we have to ensure */
3057	/* to pass a minimum nonzero value to the backend */	3842	/* to pass a minimum nonzero value to the backend */
3058	if (expect_false (waittime < backend_mintime))	3843	if (ecb_expect_false (waittime < backend_mintime))
3059	waittime = backend_mintime;	3844	waittime = backend_mintime;
3060		3845
3061	/* extra check because io_blocktime is commonly 0 */	3846	/* extra check because io_blocktime is commonly 0 */
3062	if (expect_false (io_blocktime))	3847	if (ecb_expect_false (io_blocktime))
3063	{	3848	{
3064	sleeptime = io_blocktime - (mn_now - prev_mn_now);	3849	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3065		3850
3066	if (sleeptime > waittime - backend_mintime)	3851	if (sleeptime > waittime - backend_mintime)
3067	sleeptime = waittime - backend_mintime;	3852	sleeptime = waittime - backend_mintime;
3068		3853
3069	if (expect_true (sleeptime > 0.))	3854	if (ecb_expect_true (sleeptime > 0.))
3070	{	3855	{
3071	ev_sleep (sleeptime);	3856	ev_sleep (sleeptime);
3072	waittime -= sleeptime;	3857	waittime -= sleeptime;
3073	}	3858	}
3074	}	3859	}
…		…
3081	backend_poll (EV_A_ waittime);	3866	backend_poll (EV_A_ waittime);
3082	assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */	3867	assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
3083		3868
3084	pipe_write_wanted = 0; /* just an optimisation, no fence needed */	3869	pipe_write_wanted = 0; /* just an optimisation, no fence needed */
3085		3870
		3871	ECB_MEMORY_FENCE_ACQUIRE;
3086	if (pipe_write_skipped)	3872	if (pipe_write_skipped)
3087	{	3873	{
3088	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	3874	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3089	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3875	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3090	}	3876	}
3091		3877
3092
3093	/* update ev_rt_now, do magic */	3878	/* update ev_rt_now, do magic */
3094	time_update (EV_A_ waittime + sleeptime);	3879	time_update (EV_A_ waittime + sleeptime);
3095	}	3880	}
3096		3881
3097	/* queue pending timers and reschedule them */	3882	/* queue pending timers and reschedule them */
…		…
3105	idle_reify (EV_A);	3890	idle_reify (EV_A);
3106	#endif	3891	#endif
3107		3892
3108	#if EV_CHECK_ENABLE	3893	#if EV_CHECK_ENABLE
3109	/* queue check watchers, to be executed first */	3894	/* queue check watchers, to be executed first */
3110	if (expect_false (checkcnt))	3895	if (ecb_expect_false (checkcnt))
3111	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	3896	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3112	#endif	3897	#endif
3113		3898
3114	EV_INVOKE_PENDING;	3899	EV_INVOKE_PENDING;
3115	}	3900	}
3116	while (expect_true (	3901	while (ecb_expect_true (
3117	activecnt	3902	activecnt
3118	&& !loop_done	3903	&& !loop_done
3119	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))	3904	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3120	));	3905	));
3121		3906
…		…
3128		3913
3129	return activecnt;	3914	return activecnt;
3130	}	3915	}
3131		3916
3132	void	3917	void
3133	ev_break (EV_P_ int how) EV_THROW	3918	ev_break (EV_P_ int how) EV_NOEXCEPT
3134	{	3919	{
3135	loop_done = how;	3920	loop_done = how;
3136	}	3921	}
3137		3922
3138	void	3923	void
3139	ev_ref (EV_P) EV_THROW	3924	ev_ref (EV_P) EV_NOEXCEPT
3140	{	3925	{
3141	++activecnt;	3926	++activecnt;
3142	}	3927	}
3143		3928
3144	void	3929	void
3145	ev_unref (EV_P) EV_THROW	3930	ev_unref (EV_P) EV_NOEXCEPT
3146	{	3931	{
3147	--activecnt;	3932	--activecnt;
3148	}	3933	}
3149		3934
3150	void	3935	void
3151	ev_now_update (EV_P) EV_THROW	3936	ev_now_update (EV_P) EV_NOEXCEPT
3152	{	3937	{
3153	time_update (EV_A_ 1e100);	3938	time_update (EV_A_ 1e100);
3154	}	3939	}
3155		3940
3156	void	3941	void
3157	ev_suspend (EV_P) EV_THROW	3942	ev_suspend (EV_P) EV_NOEXCEPT
3158	{	3943	{
3159	ev_now_update (EV_A);	3944	ev_now_update (EV_A);
3160	}	3945	}
3161		3946
3162	void	3947	void
3163	ev_resume (EV_P) EV_THROW	3948	ev_resume (EV_P) EV_NOEXCEPT
3164	{	3949	{
3165	ev_tstamp mn_prev = mn_now;	3950	ev_tstamp mn_prev = mn_now;
3166		3951
3167	ev_now_update (EV_A);	3952	ev_now_update (EV_A);
3168	timers_reschedule (EV_A_ mn_now - mn_prev);	3953	timers_reschedule (EV_A_ mn_now - mn_prev);
…		…
3185	inline_size void	3970	inline_size void
3186	wlist_del (WL *head, WL elem)	3971	wlist_del (WL *head, WL elem)
3187	{	3972	{
3188	while (*head)	3973	while (*head)
3189	{	3974	{
3190	if (expect_true (*head == elem))	3975	if (ecb_expect_true (*head == elem))
3191	{	3976	{
3192	*head = elem->next;	3977	*head = elem->next;
3193	break;	3978	break;
3194	}	3979	}
3195		3980
…		…
3207	w->pending = 0;	3992	w->pending = 0;
3208	}	3993	}
3209	}	3994	}
3210		3995
3211	int	3996	int
3212	ev_clear_pending (EV_P_ void *w) EV_THROW	3997	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3213	{	3998	{
3214	W w_ = (W)w;	3999	W w_ = (W)w;
3215	int pending = w_->pending;	4000	int pending = w_->pending;
3216		4001
3217	if (expect_true (pending))	4002	if (ecb_expect_true (pending))
3218	{	4003	{
3219	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	4004	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3220	p->w = (W)&pending_w;	4005	p->w = (W)&pending_w;
3221	w_->pending = 0;	4006	w_->pending = 0;
3222	return p->events;	4007	return p->events;
…		…
3249	w->active = 0;	4034	w->active = 0;
3250	}	4035	}
3251		4036
3252	/*****************************************************************************/	4037	/*****************************************************************************/
3253		4038
3254	void noinline	4039	ecb_noinline
		4040	void
3255	ev_io_start (EV_P_ ev_io *w) EV_THROW	4041	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3256	{	4042	{
3257	int fd = w->fd;	4043	int fd = w->fd;
3258		4044
3259	if (expect_false (ev_is_active (w)))	4045	if (ecb_expect_false (ev_is_active (w)))
3260	return;	4046	return;
3261		4047
3262	assert (("libev: ev_io_start called with negative fd", fd >= 0));	4048	assert (("libev: ev_io_start called with negative fd", fd >= 0));
3263	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));	4049	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3264		4050
		4051	#if EV_VERIFY >= 2
		4052	assert (("libev: ev_io_start called on watcher with invalid fd", fd_valid (fd)));
		4053	#endif
3265	EV_FREQUENT_CHECK;	4054	EV_FREQUENT_CHECK;
3266		4055
3267	ev_start (EV_A_ (W)w, 1);	4056	ev_start (EV_A_ (W)w, 1);
3268	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	4057	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);
3269	wlist_add (&anfds[fd].head, (WL)w);	4058	wlist_add (&anfds[fd].head, (WL)w);
3270		4059
3271	/* common bug, apparently */	4060	/* common bug, apparently */
3272	assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));	4061	assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3273		4062
…		…
3275	w->events &= ~EV__IOFDSET;	4064	w->events &= ~EV__IOFDSET;
3276		4065
3277	EV_FREQUENT_CHECK;	4066	EV_FREQUENT_CHECK;
3278	}	4067	}
3279		4068
3280	void noinline	4069	ecb_noinline
		4070	void
3281	ev_io_stop (EV_P_ ev_io *w) EV_THROW	4071	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3282	{	4072	{
3283	clear_pending (EV_A_ (W)w);	4073	clear_pending (EV_A_ (W)w);
3284	if (expect_false (!ev_is_active (w)))	4074	if (ecb_expect_false (!ev_is_active (w)))
3285	return;	4075	return;
3286		4076
3287	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));	4077	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3288		4078
		4079	#if EV_VERIFY >= 2
		4080	assert (("libev: ev_io_stop called on watcher with invalid fd", fd_valid (w->fd)));
		4081	#endif
3289	EV_FREQUENT_CHECK;	4082	EV_FREQUENT_CHECK;
3290		4083
3291	wlist_del (&anfds[w->fd].head, (WL)w);	4084	wlist_del (&anfds[w->fd].head, (WL)w);
3292	ev_stop (EV_A_ (W)w);	4085	ev_stop (EV_A_ (W)w);
3293		4086
3294	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	4087	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3295		4088
3296	EV_FREQUENT_CHECK;	4089	EV_FREQUENT_CHECK;
3297	}	4090	}
3298		4091
3299	void noinline	4092	ecb_noinline
		4093	void
3300	ev_timer_start (EV_P_ ev_timer *w) EV_THROW	4094	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3301	{	4095	{
3302	if (expect_false (ev_is_active (w)))	4096	if (ecb_expect_false (ev_is_active (w)))
3303	return;	4097	return;
3304		4098
3305	ev_at (w) += mn_now;	4099	ev_at (w) += mn_now;
3306		4100
3307	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));	4101	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
3308		4102
3309	EV_FREQUENT_CHECK;	4103	EV_FREQUENT_CHECK;
3310		4104
3311	++timercnt;	4105	++timercnt;
3312	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);	4106	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
3313	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);	4107	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, array_needsize_noinit);
3314	ANHE_w (timers [ev_active (w)]) = (WT)w;	4108	ANHE_w (timers [ev_active (w)]) = (WT)w;
3315	ANHE_at_cache (timers [ev_active (w)]);	4109	ANHE_at_cache (timers [ev_active (w)]);
3316	upheap (timers, ev_active (w));	4110	upheap (timers, ev_active (w));
3317		4111
3318	EV_FREQUENT_CHECK;	4112	EV_FREQUENT_CHECK;
3319		4113
3320	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	4114	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3321	}	4115	}
3322		4116
3323	void noinline	4117	ecb_noinline
		4118	void
3324	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW	4119	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3325	{	4120	{
3326	clear_pending (EV_A_ (W)w);	4121	clear_pending (EV_A_ (W)w);
3327	if (expect_false (!ev_is_active (w)))	4122	if (ecb_expect_false (!ev_is_active (w)))
3328	return;	4123	return;
3329		4124
3330	EV_FREQUENT_CHECK;	4125	EV_FREQUENT_CHECK;
3331		4126
3332	{	4127	{
…		…
3334		4129
3335	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));	4130	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
3336		4131
3337	--timercnt;	4132	--timercnt;
3338		4133
3339	if (expect_true (active < timercnt + HEAP0))	4134	if (ecb_expect_true (active < timercnt + HEAP0))
3340	{	4135	{
3341	timers [active] = timers [timercnt + HEAP0];	4136	timers [active] = timers [timercnt + HEAP0];
3342	adjustheap (timers, timercnt, active);	4137	adjustheap (timers, timercnt, active);
3343	}	4138	}
3344	}	4139	}
…		…
3348	ev_stop (EV_A_ (W)w);	4143	ev_stop (EV_A_ (W)w);
3349		4144
3350	EV_FREQUENT_CHECK;	4145	EV_FREQUENT_CHECK;
3351	}	4146	}
3352		4147
3353	void noinline	4148	ecb_noinline
		4149	void
3354	ev_timer_again (EV_P_ ev_timer *w) EV_THROW	4150	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
3355	{	4151	{
3356	EV_FREQUENT_CHECK;	4152	EV_FREQUENT_CHECK;
3357		4153
3358	clear_pending (EV_A_ (W)w);	4154	clear_pending (EV_A_ (W)w);
3359		4155
…		…
3376		4172
3377	EV_FREQUENT_CHECK;	4173	EV_FREQUENT_CHECK;
3378	}	4174	}
3379		4175
3380	ev_tstamp	4176	ev_tstamp
3381	ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW	4177	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
3382	{	4178	{
3383	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4179	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3384	}	4180	}
3385		4181
3386	#if EV_PERIODIC_ENABLE	4182	#if EV_PERIODIC_ENABLE
3387	void noinline	4183	ecb_noinline
		4184	void
3388	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW	4185	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
3389	{	4186	{
3390	if (expect_false (ev_is_active (w)))	4187	if (ecb_expect_false (ev_is_active (w)))
3391	return;	4188	return;
3392		4189
3393	if (w->reschedule_cb)	4190	if (w->reschedule_cb)
3394	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4191	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3395	else if (w->interval)	4192	else if (w->interval)
…		…
3402		4199
3403	EV_FREQUENT_CHECK;	4200	EV_FREQUENT_CHECK;
3404		4201
3405	++periodiccnt;	4202	++periodiccnt;
3406	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);	4203	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
3407	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);	4204	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, array_needsize_noinit);
3408	ANHE_w (periodics [ev_active (w)]) = (WT)w;	4205	ANHE_w (periodics [ev_active (w)]) = (WT)w;
3409	ANHE_at_cache (periodics [ev_active (w)]);	4206	ANHE_at_cache (periodics [ev_active (w)]);
3410	upheap (periodics, ev_active (w));	4207	upheap (periodics, ev_active (w));
3411		4208
3412	EV_FREQUENT_CHECK;	4209	EV_FREQUENT_CHECK;
3413		4210
3414	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4211	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3415	}	4212	}
3416		4213
3417	void noinline	4214	ecb_noinline
		4215	void
3418	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW	4216	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
3419	{	4217	{
3420	clear_pending (EV_A_ (W)w);	4218	clear_pending (EV_A_ (W)w);
3421	if (expect_false (!ev_is_active (w)))	4219	if (ecb_expect_false (!ev_is_active (w)))
3422	return;	4220	return;
3423		4221
3424	EV_FREQUENT_CHECK;	4222	EV_FREQUENT_CHECK;
3425		4223
3426	{	4224	{
…		…
3428		4226
3429	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));	4227	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
3430		4228
3431	--periodiccnt;	4229	--periodiccnt;
3432		4230
3433	if (expect_true (active < periodiccnt + HEAP0))	4231	if (ecb_expect_true (active < periodiccnt + HEAP0))
3434	{	4232	{
3435	periodics [active] = periodics [periodiccnt + HEAP0];	4233	periodics [active] = periodics [periodiccnt + HEAP0];
3436	adjustheap (periodics, periodiccnt, active);	4234	adjustheap (periodics, periodiccnt, active);
3437	}	4235	}
3438	}	4236	}
…		…
3440	ev_stop (EV_A_ (W)w);	4238	ev_stop (EV_A_ (W)w);
3441		4239
3442	EV_FREQUENT_CHECK;	4240	EV_FREQUENT_CHECK;
3443	}	4241	}
3444		4242
3445	void noinline	4243	ecb_noinline
		4244	void
3446	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW	4245	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
3447	{	4246	{
3448	/* TODO: use adjustheap and recalculation */	4247	/* TODO: use adjustheap and recalculation */
3449	ev_periodic_stop (EV_A_ w);	4248	ev_periodic_stop (EV_A_ w);
3450	ev_periodic_start (EV_A_ w);	4249	ev_periodic_start (EV_A_ w);
3451	}	4250	}
…		…
3455	# define SA_RESTART 0	4254	# define SA_RESTART 0
3456	#endif	4255	#endif
3457		4256
3458	#if EV_SIGNAL_ENABLE	4257	#if EV_SIGNAL_ENABLE
3459		4258
3460	void noinline	4259	ecb_noinline
		4260	void
3461	ev_signal_start (EV_P_ ev_signal *w) EV_THROW	4261	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
3462	{	4262	{
3463	if (expect_false (ev_is_active (w)))	4263	if (ecb_expect_false (ev_is_active (w)))
3464	return;	4264	return;
3465		4265
3466	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4266	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
3467		4267
3468	#if EV_MULTIPLICITY	4268	#if EV_MULTIPLICITY
3469	assert (("libev: a signal must not be attached to two different loops",	4269	assert (("libev: a signal must not be attached to two different loops",
3470	!signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));	4270	!signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3471		4271
3472	signals [w->signum - 1].loop = EV_A;	4272	signals [w->signum - 1].loop = EV_A;
		4273	ECB_MEMORY_FENCE_RELEASE;
3473	#endif	4274	#endif
3474		4275
3475	EV_FREQUENT_CHECK;	4276	EV_FREQUENT_CHECK;
3476		4277
3477	#if EV_USE_SIGNALFD	4278	#if EV_USE_SIGNALFD
…		…
3536	}	4337	}
3537		4338
3538	EV_FREQUENT_CHECK;	4339	EV_FREQUENT_CHECK;
3539	}	4340	}
3540		4341
3541	void noinline	4342	ecb_noinline
		4343	void
3542	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW	4344	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
3543	{	4345	{
3544	clear_pending (EV_A_ (W)w);	4346	clear_pending (EV_A_ (W)w);
3545	if (expect_false (!ev_is_active (w)))	4347	if (ecb_expect_false (!ev_is_active (w)))
3546	return;	4348	return;
3547		4349
3548	EV_FREQUENT_CHECK;	4350	EV_FREQUENT_CHECK;
3549		4351
3550	wlist_del (&signals [w->signum - 1].head, (WL)w);	4352	wlist_del (&signals [w->signum - 1].head, (WL)w);
…		…
3578	#endif	4380	#endif
3579		4381
3580	#if EV_CHILD_ENABLE	4382	#if EV_CHILD_ENABLE
3581		4383
3582	void	4384	void
3583	ev_child_start (EV_P_ ev_child *w) EV_THROW	4385	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
3584	{	4386	{
3585	#if EV_MULTIPLICITY	4387	#if EV_MULTIPLICITY
3586	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4388	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3587	#endif	4389	#endif
3588	if (expect_false (ev_is_active (w)))	4390	if (ecb_expect_false (ev_is_active (w)))
3589	return;	4391	return;
3590		4392
3591	EV_FREQUENT_CHECK;	4393	EV_FREQUENT_CHECK;
3592		4394
3593	ev_start (EV_A_ (W)w, 1);	4395	ev_start (EV_A_ (W)w, 1);
…		…
3595		4397
3596	EV_FREQUENT_CHECK;	4398	EV_FREQUENT_CHECK;
3597	}	4399	}
3598		4400
3599	void	4401	void
3600	ev_child_stop (EV_P_ ev_child *w) EV_THROW	4402	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
3601	{	4403	{
3602	clear_pending (EV_A_ (W)w);	4404	clear_pending (EV_A_ (W)w);
3603	if (expect_false (!ev_is_active (w)))	4405	if (ecb_expect_false (!ev_is_active (w)))
3604	return;	4406	return;
3605		4407
3606	EV_FREQUENT_CHECK;	4408	EV_FREQUENT_CHECK;
3607		4409
3608	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);	4410	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
…		…
3622		4424
3623	#define DEF_STAT_INTERVAL 5.0074891	4425	#define DEF_STAT_INTERVAL 5.0074891
3624	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4426	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
3625	#define MIN_STAT_INTERVAL 0.1074891	4427	#define MIN_STAT_INTERVAL 0.1074891
3626		4428
3627	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4429	ecb_noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
3628		4430
3629	#if EV_USE_INOTIFY	4431	#if EV_USE_INOTIFY
3630		4432
3631	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4433	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
3632	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4434	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3633		4435
3634	static void noinline	4436	ecb_noinline
		4437	static void
3635	infy_add (EV_P_ ev_stat *w)	4438	infy_add (EV_P_ ev_stat *w)
3636	{	4439	{
3637	w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD);	4440	w->wd = inotify_add_watch (fs_fd, w->path,
		4441	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
		4442	| IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
		4443	| IN_DONT_FOLLOW | IN_MASK_ADD);
3638		4444
3639	if (w->wd >= 0)	4445	if (w->wd >= 0)
3640	{	4446	{
3641	struct statfs sfs;	4447	struct statfs sfs;
3642		4448
…		…
3646		4452
3647	if (!fs_2625)	4453	if (!fs_2625)
3648	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	4454	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3649	else if (!statfs (w->path, &sfs)	4455	else if (!statfs (w->path, &sfs)
3650	&& (sfs.f_type == 0x1373 /* devfs */	4456	&& (sfs.f_type == 0x1373 /* devfs */
		4457	|| sfs.f_type == 0x4006 /* fat */
		4458	|| sfs.f_type == 0x4d44 /* msdos */
3651	|| sfs.f_type == 0xEF53 /* ext2/3 */	4459	|| sfs.f_type == 0xEF53 /* ext2/3 */
		4460	|| sfs.f_type == 0x72b6 /* jffs2 */
		4461	|| sfs.f_type == 0x858458f6 /* ramfs */
		4462	|| sfs.f_type == 0x5346544e /* ntfs */
3652	|| sfs.f_type == 0x3153464a /* jfs */	4463	|| sfs.f_type == 0x3153464a /* jfs */
		4464	|| sfs.f_type == 0x9123683e /* btrfs */
3653	|| sfs.f_type == 0x52654973 /* reiser3 */	4465	|| sfs.f_type == 0x52654973 /* reiser3 */
3654	|| sfs.f_type == 0x01021994 /* tempfs */	4466	|| sfs.f_type == 0x01021994 /* tmpfs */
3655	|| sfs.f_type == 0x58465342 /* xfs */))	4467	|| sfs.f_type == 0x58465342 /* xfs */))
3656	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */	4468	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3657	else	4469	else
3658	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */	4470	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3659	}	4471	}
…		…
3694	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4506	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3695	ev_timer_again (EV_A_ &w->timer);	4507	ev_timer_again (EV_A_ &w->timer);
3696	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4508	if (ev_is_active (&w->timer)) ev_unref (EV_A);
3697	}	4509	}
3698		4510
3699	static void noinline	4511	ecb_noinline
		4512	static void
3700	infy_del (EV_P_ ev_stat *w)	4513	infy_del (EV_P_ ev_stat *w)
3701	{	4514	{
3702	int slot;	4515	int slot;
3703	int wd = w->wd;	4516	int wd = w->wd;
3704		4517
…		…
3711		4524
3712	/* remove this watcher, if others are watching it, they will rearm */	4525	/* remove this watcher, if others are watching it, they will rearm */
3713	inotify_rm_watch (fs_fd, wd);	4526	inotify_rm_watch (fs_fd, wd);
3714	}	4527	}
3715		4528
3716	static void noinline	4529	ecb_noinline
		4530	static void
3717	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4531	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
3718	{	4532	{
3719	if (slot < 0)	4533	if (slot < 0)
3720	/* overflow, need to check for all hash slots */	4534	/* overflow, need to check for all hash slots */
3721	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)	4535	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
…		…
3757	infy_wd (EV_A_ ev->wd, ev->wd, ev);	4571	infy_wd (EV_A_ ev->wd, ev->wd, ev);
3758	ofs += sizeof (struct inotify_event) + ev->len;	4572	ofs += sizeof (struct inotify_event) + ev->len;
3759	}	4573	}
3760	}	4574	}
3761		4575
3762	inline_size void ecb_cold	4576	inline_size ecb_cold
		4577	void
3763	ev_check_2625 (EV_P)	4578	ev_check_2625 (EV_P)
3764	{	4579	{
3765	/* kernels < 2.6.25 are borked	4580	/* kernels < 2.6.25 are borked
3766	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	4581	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
3767	*/	4582	*/
…		…
3857	#else	4672	#else
3858	# define EV_LSTAT(p,b) lstat (p, b)	4673	# define EV_LSTAT(p,b) lstat (p, b)
3859	#endif	4674	#endif
3860		4675
3861	void	4676	void
3862	ev_stat_stat (EV_P_ ev_stat *w) EV_THROW	4677	ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT
3863	{	4678	{
3864	if (lstat (w->path, &w->attr) < 0)	4679	if (lstat (w->path, &w->attr) < 0)
3865	w->attr.st_nlink = 0;	4680	w->attr.st_nlink = 0;
3866	else if (!w->attr.st_nlink)	4681	else if (!w->attr.st_nlink)
3867	w->attr.st_nlink = 1;	4682	w->attr.st_nlink = 1;
3868	}	4683	}
3869		4684
3870	static void noinline	4685	ecb_noinline
		4686	static void
3871	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4687	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3872	{	4688	{
3873	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4689	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
3874		4690
3875	ev_statdata prev = w->attr;	4691	ev_statdata prev = w->attr;
…		…
3906	ev_feed_event (EV_A_ w, EV_STAT);	4722	ev_feed_event (EV_A_ w, EV_STAT);
3907	}	4723	}
3908	}	4724	}
3909		4725
3910	void	4726	void
3911	ev_stat_start (EV_P_ ev_stat *w) EV_THROW	4727	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
3912	{	4728	{
3913	if (expect_false (ev_is_active (w)))	4729	if (ecb_expect_false (ev_is_active (w)))
3914	return;	4730	return;
3915		4731
3916	ev_stat_stat (EV_A_ w);	4732	ev_stat_stat (EV_A_ w);
3917		4733
3918	if (w->interval < MIN_STAT_INTERVAL && w->interval)	4734	if (w->interval < MIN_STAT_INTERVAL && w->interval)
…		…
3937		4753
3938	EV_FREQUENT_CHECK;	4754	EV_FREQUENT_CHECK;
3939	}	4755	}
3940		4756
3941	void	4757	void
3942	ev_stat_stop (EV_P_ ev_stat *w) EV_THROW	4758	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
3943	{	4759	{
3944	clear_pending (EV_A_ (W)w);	4760	clear_pending (EV_A_ (W)w);
3945	if (expect_false (!ev_is_active (w)))	4761	if (ecb_expect_false (!ev_is_active (w)))
3946	return;	4762	return;
3947		4763
3948	EV_FREQUENT_CHECK;	4764	EV_FREQUENT_CHECK;
3949		4765
3950	#if EV_USE_INOTIFY	4766	#if EV_USE_INOTIFY
…		…
3963	}	4779	}
3964	#endif	4780	#endif
3965		4781
3966	#if EV_IDLE_ENABLE	4782	#if EV_IDLE_ENABLE
3967	void	4783	void
3968	ev_idle_start (EV_P_ ev_idle *w) EV_THROW	4784	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
3969	{	4785	{
3970	if (expect_false (ev_is_active (w)))	4786	if (ecb_expect_false (ev_is_active (w)))
3971	return;	4787	return;
3972		4788
3973	pri_adjust (EV_A_ (W)w);	4789	pri_adjust (EV_A_ (W)w);
3974		4790
3975	EV_FREQUENT_CHECK;	4791	EV_FREQUENT_CHECK;
…		…
3978	int active = ++idlecnt [ABSPRI (w)];	4794	int active = ++idlecnt [ABSPRI (w)];
3979		4795
3980	++idleall;	4796	++idleall;
3981	ev_start (EV_A_ (W)w, active);	4797	ev_start (EV_A_ (W)w, active);
3982		4798
3983	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);	4799	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, array_needsize_noinit);
3984	idles [ABSPRI (w)][active - 1] = w;	4800	idles [ABSPRI (w)][active - 1] = w;
3985	}	4801	}
3986		4802
3987	EV_FREQUENT_CHECK;	4803	EV_FREQUENT_CHECK;
3988	}	4804	}
3989		4805
3990	void	4806	void
3991	ev_idle_stop (EV_P_ ev_idle *w) EV_THROW	4807	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
3992	{	4808	{
3993	clear_pending (EV_A_ (W)w);	4809	clear_pending (EV_A_ (W)w);
3994	if (expect_false (!ev_is_active (w)))	4810	if (ecb_expect_false (!ev_is_active (w)))
3995	return;	4811	return;
3996		4812
3997	EV_FREQUENT_CHECK;	4813	EV_FREQUENT_CHECK;
3998		4814
3999	{	4815	{
…		…
4010	}	4826	}
4011	#endif	4827	#endif
4012		4828
4013	#if EV_PREPARE_ENABLE	4829	#if EV_PREPARE_ENABLE
4014	void	4830	void
4015	ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW	4831	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4016	{	4832	{
4017	if (expect_false (ev_is_active (w)))	4833	if (ecb_expect_false (ev_is_active (w)))
4018	return;	4834	return;
4019		4835
4020	EV_FREQUENT_CHECK;	4836	EV_FREQUENT_CHECK;
4021		4837
4022	ev_start (EV_A_ (W)w, ++preparecnt);	4838	ev_start (EV_A_ (W)w, ++preparecnt);
4023	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);	4839	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, array_needsize_noinit);
4024	prepares [preparecnt - 1] = w;	4840	prepares [preparecnt - 1] = w;
4025		4841
4026	EV_FREQUENT_CHECK;	4842	EV_FREQUENT_CHECK;
4027	}	4843	}
4028		4844
4029	void	4845	void
4030	ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW	4846	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4031	{	4847	{
4032	clear_pending (EV_A_ (W)w);	4848	clear_pending (EV_A_ (W)w);
4033	if (expect_false (!ev_is_active (w)))	4849	if (ecb_expect_false (!ev_is_active (w)))
4034	return;	4850	return;
4035		4851
4036	EV_FREQUENT_CHECK;	4852	EV_FREQUENT_CHECK;
4037		4853
4038	{	4854	{
…		…
4048	}	4864	}
4049	#endif	4865	#endif
4050		4866
4051	#if EV_CHECK_ENABLE	4867	#if EV_CHECK_ENABLE
4052	void	4868	void
4053	ev_check_start (EV_P_ ev_check *w) EV_THROW	4869	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4054	{	4870	{
4055	if (expect_false (ev_is_active (w)))	4871	if (ecb_expect_false (ev_is_active (w)))
4056	return;	4872	return;
4057		4873
4058	EV_FREQUENT_CHECK;	4874	EV_FREQUENT_CHECK;
4059		4875
4060	ev_start (EV_A_ (W)w, ++checkcnt);	4876	ev_start (EV_A_ (W)w, ++checkcnt);
4061	array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);	4877	array_needsize (ev_check *, checks, checkmax, checkcnt, array_needsize_noinit);
4062	checks [checkcnt - 1] = w;	4878	checks [checkcnt - 1] = w;
4063		4879
4064	EV_FREQUENT_CHECK;	4880	EV_FREQUENT_CHECK;
4065	}	4881	}
4066		4882
4067	void	4883	void
4068	ev_check_stop (EV_P_ ev_check *w) EV_THROW	4884	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4069	{	4885	{
4070	clear_pending (EV_A_ (W)w);	4886	clear_pending (EV_A_ (W)w);
4071	if (expect_false (!ev_is_active (w)))	4887	if (ecb_expect_false (!ev_is_active (w)))
4072	return;	4888	return;
4073		4889
4074	EV_FREQUENT_CHECK;	4890	EV_FREQUENT_CHECK;
4075		4891
4076	{	4892	{
…		…
4085	EV_FREQUENT_CHECK;	4901	EV_FREQUENT_CHECK;
4086	}	4902	}
4087	#endif	4903	#endif
4088		4904
4089	#if EV_EMBED_ENABLE	4905	#if EV_EMBED_ENABLE
4090	void noinline	4906	ecb_noinline
		4907	void
4091	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW	4908	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4092	{	4909	{
4093	ev_run (w->other, EVRUN_NOWAIT);	4910	ev_run (w->other, EVRUN_NOWAIT);
4094	}	4911	}
4095		4912
4096	static void	4913	static void
…		…
4144	ev_idle_stop (EV_A_ idle);	4961	ev_idle_stop (EV_A_ idle);
4145	}	4962	}
4146	#endif	4963	#endif
4147		4964
4148	void	4965	void
4149	ev_embed_start (EV_P_ ev_embed *w) EV_THROW	4966	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4150	{	4967	{
4151	if (expect_false (ev_is_active (w)))	4968	if (ecb_expect_false (ev_is_active (w)))
4152	return;	4969	return;
4153		4970
4154	{	4971	{
4155	EV_P = w->other;	4972	EV_P = w->other;
4156	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));	4973	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
…		…
4175		4992
4176	EV_FREQUENT_CHECK;	4993	EV_FREQUENT_CHECK;
4177	}	4994	}
4178		4995
4179	void	4996	void
4180	ev_embed_stop (EV_P_ ev_embed *w) EV_THROW	4997	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4181	{	4998	{
4182	clear_pending (EV_A_ (W)w);	4999	clear_pending (EV_A_ (W)w);
4183	if (expect_false (!ev_is_active (w)))	5000	if (ecb_expect_false (!ev_is_active (w)))
4184	return;	5001	return;
4185		5002
4186	EV_FREQUENT_CHECK;	5003	EV_FREQUENT_CHECK;
4187		5004
4188	ev_io_stop (EV_A_ &w->io);	5005	ev_io_stop (EV_A_ &w->io);
…		…
4195	}	5012	}
4196	#endif	5013	#endif
4197		5014
4198	#if EV_FORK_ENABLE	5015	#if EV_FORK_ENABLE
4199	void	5016	void
4200	ev_fork_start (EV_P_ ev_fork *w) EV_THROW	5017	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4201	{	5018	{
4202	if (expect_false (ev_is_active (w)))	5019	if (ecb_expect_false (ev_is_active (w)))
4203	return;	5020	return;
4204		5021
4205	EV_FREQUENT_CHECK;	5022	EV_FREQUENT_CHECK;
4206		5023
4207	ev_start (EV_A_ (W)w, ++forkcnt);	5024	ev_start (EV_A_ (W)w, ++forkcnt);
4208	array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);	5025	array_needsize (ev_fork *, forks, forkmax, forkcnt, array_needsize_noinit);
4209	forks [forkcnt - 1] = w;	5026	forks [forkcnt - 1] = w;
4210		5027
4211	EV_FREQUENT_CHECK;	5028	EV_FREQUENT_CHECK;
4212	}	5029	}
4213		5030
4214	void	5031	void
4215	ev_fork_stop (EV_P_ ev_fork *w) EV_THROW	5032	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4216	{	5033	{
4217	clear_pending (EV_A_ (W)w);	5034	clear_pending (EV_A_ (W)w);
4218	if (expect_false (!ev_is_active (w)))	5035	if (ecb_expect_false (!ev_is_active (w)))
4219	return;	5036	return;
4220		5037
4221	EV_FREQUENT_CHECK;	5038	EV_FREQUENT_CHECK;
4222		5039
4223	{	5040	{
…		…
4233	}	5050	}
4234	#endif	5051	#endif
4235		5052
4236	#if EV_CLEANUP_ENABLE	5053	#if EV_CLEANUP_ENABLE
4237	void	5054	void
4238	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW	5055	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4239	{	5056	{
4240	if (expect_false (ev_is_active (w)))	5057	if (ecb_expect_false (ev_is_active (w)))
4241	return;	5058	return;
4242		5059
4243	EV_FREQUENT_CHECK;	5060	EV_FREQUENT_CHECK;
4244		5061
4245	ev_start (EV_A_ (W)w, ++cleanupcnt);	5062	ev_start (EV_A_ (W)w, ++cleanupcnt);
4246	array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2);	5063	array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, array_needsize_noinit);
4247	cleanups [cleanupcnt - 1] = w;	5064	cleanups [cleanupcnt - 1] = w;
4248		5065
4249	/* cleanup watchers should never keep a refcount on the loop */	5066	/* cleanup watchers should never keep a refcount on the loop */
4250	ev_unref (EV_A);	5067	ev_unref (EV_A);
4251	EV_FREQUENT_CHECK;	5068	EV_FREQUENT_CHECK;
4252	}	5069	}
4253		5070
4254	void	5071	void
4255	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW	5072	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4256	{	5073	{
4257	clear_pending (EV_A_ (W)w);	5074	clear_pending (EV_A_ (W)w);
4258	if (expect_false (!ev_is_active (w)))	5075	if (ecb_expect_false (!ev_is_active (w)))
4259	return;	5076	return;
4260		5077
4261	EV_FREQUENT_CHECK;	5078	EV_FREQUENT_CHECK;
4262	ev_ref (EV_A);	5079	ev_ref (EV_A);
4263		5080
…		…
4274	}	5091	}
4275	#endif	5092	#endif
4276		5093
4277	#if EV_ASYNC_ENABLE	5094	#if EV_ASYNC_ENABLE
4278	void	5095	void
4279	ev_async_start (EV_P_ ev_async *w) EV_THROW	5096	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4280	{	5097	{
4281	if (expect_false (ev_is_active (w)))	5098	if (ecb_expect_false (ev_is_active (w)))
4282	return;	5099	return;
4283		5100
4284	w->sent = 0;	5101	w->sent = 0;
4285		5102
4286	evpipe_init (EV_A);	5103	evpipe_init (EV_A);
4287		5104
4288	EV_FREQUENT_CHECK;	5105	EV_FREQUENT_CHECK;
4289		5106
4290	ev_start (EV_A_ (W)w, ++asynccnt);	5107	ev_start (EV_A_ (W)w, ++asynccnt);
4291	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);	5108	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, array_needsize_noinit);
4292	asyncs [asynccnt - 1] = w;	5109	asyncs [asynccnt - 1] = w;
4293		5110
4294	EV_FREQUENT_CHECK;	5111	EV_FREQUENT_CHECK;
4295	}	5112	}
4296		5113
4297	void	5114	void
4298	ev_async_stop (EV_P_ ev_async *w) EV_THROW	5115	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4299	{	5116	{
4300	clear_pending (EV_A_ (W)w);	5117	clear_pending (EV_A_ (W)w);
4301	if (expect_false (!ev_is_active (w)))	5118	if (ecb_expect_false (!ev_is_active (w)))
4302	return;	5119	return;
4303		5120
4304	EV_FREQUENT_CHECK;	5121	EV_FREQUENT_CHECK;
4305		5122
4306	{	5123	{
…		…
4314		5131
4315	EV_FREQUENT_CHECK;	5132	EV_FREQUENT_CHECK;
4316	}	5133	}
4317		5134
4318	void	5135	void
4319	ev_async_send (EV_P_ ev_async *w) EV_THROW	5136	ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT
4320	{	5137	{
4321	w->sent = 1;	5138	w->sent = 1;
4322	evpipe_write (EV_A_ &async_pending);	5139	evpipe_write (EV_A_ &async_pending);
4323	}	5140	}
4324	#endif	5141	#endif
…		…
4361		5178
4362	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));	5179	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4363	}	5180	}
4364		5181
4365	void	5182	void
4366	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW	5183	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT
4367	{	5184	{
4368	struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));	5185	struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
4369
4370	if (expect_false (!once))
4371	{
4372	cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMER, arg);
4373	return;
4374	}
4375		5186
4376	once->cb = cb;	5187	once->cb = cb;
4377	once->arg = arg;	5188	once->arg = arg;
4378		5189
4379	ev_init (&once->io, once_cb_io);	5190	ev_init (&once->io, once_cb_io);
…		…
4392	}	5203	}
4393		5204
4394	/*****************************************************************************/	5205	/*****************************************************************************/
4395		5206
4396	#if EV_WALK_ENABLE	5207	#if EV_WALK_ENABLE
4397	void ecb_cold	5208	ecb_cold
		5209	void
4398	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW	5210	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT
4399	{	5211	{
4400	int i, j;	5212	int i, j;
4401	ev_watcher_list *wl, *wn;	5213	ev_watcher_list *wl, *wn;
4402		5214
4403	if (types & (EV_IO | EV_EMBED))	5215	if (types & (EV_IO | EV_EMBED))

Diff Legend

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