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.499 by root, Wed Jun 26 07:50:27 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
312	#ifndef EV_USE_INOTIFY	337	#ifndef EV_USE_INOTIFY
313	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))	338	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
314	# define EV_USE_INOTIFY EV_FEATURE_OS	339	# define EV_USE_INOTIFY EV_FEATURE_OS
315	# else	340	# else
316	# define EV_USE_INOTIFY 0	341	# define EV_USE_INOTIFY 0
…		…
355	# define EV_USE_4HEAP EV_FEATURE_DATA	380	# define EV_USE_4HEAP EV_FEATURE_DATA
356	#endif	381	#endif
357		382
358	#ifndef EV_HEAP_CACHE_AT	383	#ifndef EV_HEAP_CACHE_AT
359	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA	384	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
		385	#endif
		386
		387	#ifdef __ANDROID__
		388	/* supposedly, android doesn't typedef fd_mask */
		389	# undef EV_USE_SELECT
		390	# define EV_USE_SELECT 0
		391	/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
		392	# undef EV_USE_CLOCK_SYSCALL
		393	# define EV_USE_CLOCK_SYSCALL 0
		394	#endif
		395
		396	/* aix's poll.h seems to cause lots of trouble */
		397	#ifdef _AIX
		398	/* AIX has a completely broken poll.h header */
		399	# undef EV_USE_POLL
		400	# define EV_USE_POLL 0
360	#endif	401	#endif
361		402
362	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */	403	/* 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. */	404	/* which makes programs even slower. might work on other unices, too. */
364	#if EV_USE_CLOCK_SYSCALL	405	#if EV_USE_CLOCK_SYSCALL
…		…
373	# endif	414	# endif
374	#endif	415	#endif
375		416
376	/* this block fixes any misconfiguration where we know we run into trouble otherwise */	417	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
377		418
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	419	#ifndef CLOCK_MONOTONIC
385	# undef EV_USE_MONOTONIC	420	# undef EV_USE_MONOTONIC
386	# define EV_USE_MONOTONIC 0	421	# define EV_USE_MONOTONIC 0
387	#endif	422	#endif
388		423
…		…
398		433
399	#if !EV_USE_NANOSLEEP	434	#if !EV_USE_NANOSLEEP
400	/* hp-ux has it in sys/time.h, which we unconditionally include above */	435	/* hp-ux has it in sys/time.h, which we unconditionally include above */
401	# if !defined _WIN32 && !defined __hpux	436	# if !defined _WIN32 && !defined __hpux
402	# include <sys/select.h>	437	# include <sys/select.h>
		438	# endif
		439	#endif
		440
		441	#if EV_USE_LINUXAIO
		442	# include <sys/syscall.h>
		443	# if !SYS_io_getevents || !EV_USE_EPOLL /* ev_linxaio uses ev_poll.c:ev_epoll_create */
		444	# undef EV_USE_LINUXAIO
		445	# define EV_USE_LINUXAIO 0
403	# endif	446	# endif
404	#endif	447	#endif
405		448
406	#if EV_USE_INOTIFY	449	#if EV_USE_INOTIFY
407	# include <sys/statfs.h>	450	# include <sys/statfs.h>
…		…
475	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */	518	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
476	/* ECB.H BEGIN */	519	/* ECB.H BEGIN */
477	/*	520	/*
478	* libecb - http://software.schmorp.de/pkg/libecb	521	* libecb - http://software.schmorp.de/pkg/libecb
479	*	522	*
480	* Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>	523	* Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
481	* Copyright (©) 2011 Emanuele Giaquinta	524	* Copyright (©) 2011 Emanuele Giaquinta
482	* All rights reserved.	525	* All rights reserved.
483	*	526	*
484	* Redistribution and use in source and binary forms, with or without modifica-	527	* Redistribution and use in source and binary forms, with or without modifica-
485	* tion, are permitted provided that the following conditions are met:	528	* tion, are permitted provided that the following conditions are met:
…		…
499	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;	542	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
500	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,	543	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
501	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-	544	* 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	545	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
503	* OF THE POSSIBILITY OF SUCH DAMAGE.	546	* OF THE POSSIBILITY OF SUCH DAMAGE.
		547	*
		548	* Alternatively, the contents of this file may be used under the terms of
		549	* the GNU General Public License ("GPL") version 2 or any later version,
		550	* in which case the provisions of the GPL are applicable instead of
		551	* the above. If you wish to allow the use of your version of this file
		552	* only under the terms of the GPL and not to allow others to use your
		553	* version of this file under the BSD license, indicate your decision
		554	* by deleting the provisions above and replace them with the notice
		555	* and other provisions required by the GPL. If you do not delete the
		556	* provisions above, a recipient may use your version of this file under
		557	* either the BSD or the GPL.
504	*/	558	*/
505		559
506	#ifndef ECB_H	560	#ifndef ECB_H
507	#define ECB_H	561	#define ECB_H
		562
		563	/* 16 bits major, 16 bits minor */
		564	#define ECB_VERSION 0x00010006
508		565
509	#ifdef _WIN32	566	#ifdef _WIN32
510	typedef signed char int8_t;	567	typedef signed char int8_t;
511	typedef unsigned char uint8_t;	568	typedef unsigned char uint8_t;
512	typedef signed short int16_t;	569	typedef signed short int16_t;
…		…
518	typedef unsigned long long uint64_t;	575	typedef unsigned long long uint64_t;
519	#else /* _MSC_VER || __BORLANDC__ */	576	#else /* _MSC_VER || __BORLANDC__ */
520	typedef signed __int64 int64_t;	577	typedef signed __int64 int64_t;
521	typedef unsigned __int64 uint64_t;	578	typedef unsigned __int64 uint64_t;
522	#endif	579	#endif
		580	#ifdef _WIN64
		581	#define ECB_PTRSIZE 8
		582	typedef uint64_t uintptr_t;
		583	typedef int64_t intptr_t;
		584	#else
		585	#define ECB_PTRSIZE 4
		586	typedef uint32_t uintptr_t;
		587	typedef int32_t intptr_t;
		588	#endif
523	#else	589	#else
524	#include <inttypes.h>	590	#include <inttypes.h>
		591	#if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
		592	#define ECB_PTRSIZE 8
		593	#else
		594	#define ECB_PTRSIZE 4
		595	#endif
		596	#endif
		597
		598	#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
		599	#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
		600
		601	/* work around x32 idiocy by defining proper macros */
		602	#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
		603	#if _ILP32
		604	#define ECB_AMD64_X32 1
		605	#else
		606	#define ECB_AMD64 1
		607	#endif
525	#endif	608	#endif
526		609
527	/* many compilers define _GNUC_ to some versions but then only implement	610	/* many compilers define _GNUC_ to some versions but then only implement
528	* what their idiot authors think are the "more important" extensions,	611	* what their idiot authors think are the "more important" extensions,
529	* causing enormous grief in return for some better fake benchmark numbers.	612	* causing enormous grief in return for some better fake benchmark numbers.
530	* or so.	613	* or so.
531	* we try to detect these and simply assume they are not gcc - if they have	614	* 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.	615	* an issue with that they should have done it right in the first place.
533	*/	616	*/
534	#ifndef ECB_GCC_VERSION
535	#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__	617	#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	618	#define ECB_GCC_VERSION(major,minor) 0
537	#else	619	#else
538	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))	620	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
539	#endif	621	#endif
		622
		623	#define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
		624
		625	#if __clang__ && defined __has_builtin
		626	#define ECB_CLANG_BUILTIN(x) __has_builtin (x)
		627	#else
		628	#define ECB_CLANG_BUILTIN(x) 0
		629	#endif
		630
		631	#if __clang__ && defined __has_extension
		632	#define ECB_CLANG_EXTENSION(x) __has_extension (x)
		633	#else
		634	#define ECB_CLANG_EXTENSION(x) 0
		635	#endif
		636
		637	#define ECB_CPP (__cplusplus+0)
		638	#define ECB_CPP11 (__cplusplus >= 201103L)
		639	#define ECB_CPP14 (__cplusplus >= 201402L)
		640	#define ECB_CPP17 (__cplusplus >= 201703L)
		641
		642	#if ECB_CPP
		643	#define ECB_C 0
		644	#define ECB_STDC_VERSION 0
		645	#else
		646	#define ECB_C 1
		647	#define ECB_STDC_VERSION __STDC_VERSION__
		648	#endif
		649
		650	#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
		651	#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
		652	#define ECB_C17 (ECB_STDC_VERSION >= 201710L)
		653
		654	#if ECB_CPP
		655	#define ECB_EXTERN_C extern "C"
		656	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {
		657	#define ECB_EXTERN_C_END }
		658	#else
		659	#define ECB_EXTERN_C extern
		660	#define ECB_EXTERN_C_BEG
		661	#define ECB_EXTERN_C_END
540	#endif	662	#endif
541		663
542	/*****************************************************************************/	664	/*****************************************************************************/
543		665
544	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */	666	/* 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 */	667	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
546		668
547	#if ECB_NO_THREADS	669	#if ECB_NO_THREADS
548	# define ECB_NO_SMP 1	670	#define ECB_NO_SMP 1
549	#endif	671	#endif
550		672
551	#if ECB_NO_THREADS || ECB_NO_SMP	673	#if ECB_NO_SMP
552	#define ECB_MEMORY_FENCE do { } while (0)	674	#define ECB_MEMORY_FENCE do { } while (0)
		675	#endif
		676
		677	/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
		678	#if __xlC__ && ECB_CPP
		679	#include <builtins.h>
		680	#endif
		681
		682	#if 1400 <= _MSC_VER
		683	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
553	#endif	684	#endif
554		685
555	#ifndef ECB_MEMORY_FENCE	686	#ifndef ECB_MEMORY_FENCE
556	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	687	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
		688	#define ECB_MEMORY_FENCE_RELAXED __asm__ __volatile__ ("" : : : "memory")
557	#if __i386 || __i386__	689	#if __i386 || __i386__
558	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")	690	#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 */	691	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
560	#define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */	692	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
561	#elif __amd64 || __amd64__ || __x86_64 || __x86_64__	693	#elif ECB_GCC_AMD64
562	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")	694	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
563	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")	695	#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 */	696	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
565	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__	697	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
566	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	698	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
		699	#elif defined __ARM_ARCH_2__ \
		700	|| defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
		701	|| defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
		702	|| defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
		703	|| defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
		704	|| defined __ARM_ARCH_5TEJ__
		705	/* 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__ \	706	#elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
568	|| defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__	707	|| defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
		708	|| defined __ARM_ARCH_6T2__
569	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")	709	#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__ \	710	#elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
571	|| defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__	711	|| defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
572	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")	712	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
573	#elif __sparc || __sparc__	713	#elif __aarch64__
		714	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
		715	#elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
574	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad | " : : : "memory")	716	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
575	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")	717	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
576	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")	718	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
577	#elif defined __s390__ || defined __s390x__	719	#elif defined __s390__ || defined __s390x__
578	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")	720	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
579	#elif defined __mips__	721	#elif defined __mips__
		722	/* GNU/Linux emulates sync on mips1 architectures, so we force its use */
		723	/* 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")	724	#define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
581	#elif defined __alpha__	725	#elif defined __alpha__
582	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")	726	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
		727	#elif defined __hppa__
		728	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		729	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
		730	#elif defined __ia64__
		731	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
		732	#elif defined __m68k__
		733	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		734	#elif defined __m88k__
		735	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
		736	#elif defined __sh__
		737	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
583	#endif	738	#endif
584	#endif	739	#endif
585	#endif	740	#endif
586		741
587	#ifndef ECB_MEMORY_FENCE	742	#ifndef ECB_MEMORY_FENCE
		743	#if ECB_GCC_VERSION(4,7)
		744	/* see comment below (stdatomic.h) about the C11 memory model. */
		745	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
		746	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
		747	#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
		748	#define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
		749
		750	#elif ECB_CLANG_EXTENSION(c_atomic)
		751	/* see comment below (stdatomic.h) about the C11 memory model. */
		752	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
		753	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
		754	#define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
		755	#define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
		756
588	#if ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__	757	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
589	#define ECB_MEMORY_FENCE __sync_synchronize ()	758	#define ECB_MEMORY_FENCE __sync_synchronize ()
590	/*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */	759	#elif _MSC_VER >= 1500 /* VC++ 2008 */
591	/*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */	760	/* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
		761	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
		762	#define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
		763	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
		764	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
592	#elif _MSC_VER >= 1400 /* VC++ 2005 */	765	#elif _MSC_VER >= 1400 /* VC++ 2005 */
593	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)	766	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
594	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()	767	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()
595	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */	768	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
596	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()	769	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
597	#elif defined _WIN32	770	#elif defined _WIN32
598	#include <WinNT.h>	771	#include <WinNT.h>
599	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */	772	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
600	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	773	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
601	#include <mbarrier.h>	774	#include <mbarrier.h>
602	#define ECB_MEMORY_FENCE __machine_rw_barrier ()	775	#define ECB_MEMORY_FENCE __machine_rw_barrier ()
603	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()	776	#define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
604	#define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()	777	#define ECB_MEMORY_FENCE_RELEASE __machine_rel_barrier ()
		778	#define ECB_MEMORY_FENCE_RELAXED __compiler_barrier ()
605	#elif __xlC__	779	#elif __xlC__
606	#define ECB_MEMORY_FENCE __sync ()	780	#define ECB_MEMORY_FENCE __sync ()
		781	#endif
		782	#endif
		783
		784	#ifndef ECB_MEMORY_FENCE
		785	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
		786	/* we assume that these memory fences work on all variables/all memory accesses, */
		787	/* not just C11 atomics and atomic accesses */
		788	#include <stdatomic.h>
		789	#define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
		790	#define ECB_MEMORY_FENCE_ACQUIRE atomic_thread_fence (memory_order_acquire)
		791	#define ECB_MEMORY_FENCE_RELEASE atomic_thread_fence (memory_order_release)
607	#endif	792	#endif
608	#endif	793	#endif
609		794
610	#ifndef ECB_MEMORY_FENCE	795	#ifndef ECB_MEMORY_FENCE
611	#if !ECB_AVOID_PTHREADS	796	#if !ECB_AVOID_PTHREADS
…		…
631		816
632	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE	817	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
633	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	818	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
634	#endif	819	#endif
635		820
		821	#if !defined ECB_MEMORY_FENCE_RELAXED && defined ECB_MEMORY_FENCE
		822	#define ECB_MEMORY_FENCE_RELAXED ECB_MEMORY_FENCE /* very heavy-handed */
		823	#endif
		824
636	/*****************************************************************************/	825	/*****************************************************************************/
637		826
638	#define ECB_C99 (__STDC_VERSION__ >= 199901L)	827	#if ECB_CPP
639
640	#if __cplusplus
641	#define ecb_inline static inline	828	#define ecb_inline static inline
642	#elif ECB_GCC_VERSION(2,5)	829	#elif ECB_GCC_VERSION(2,5)
643	#define ecb_inline static __inline__	830	#define ecb_inline static __inline__
644	#elif ECB_C99	831	#elif ECB_C99
645	#define ecb_inline static inline	832	#define ecb_inline static inline
…		…
659		846
660	#define ECB_CONCAT_(a, b) a ## b	847	#define ECB_CONCAT_(a, b) a ## b
661	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)	848	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
662	#define ECB_STRINGIFY_(a) # a	849	#define ECB_STRINGIFY_(a) # a
663	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)	850	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
		851	#define ECB_STRINGIFY_EXPR(expr) ((expr), ECB_STRINGIFY_ (expr))
664		852
665	#define ecb_function_ ecb_inline	853	#define ecb_function_ ecb_inline
666		854
667	#if ECB_GCC_VERSION(3,1)	855	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
668	#define ecb_attribute(attrlist) __attribute__(attrlist)	856	#define ecb_attribute(attrlist) __attribute__ (attrlist)
		857	#else
		858	#define ecb_attribute(attrlist)
		859	#endif
		860
		861	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
669	#define ecb_is_constant(expr) __builtin_constant_p (expr)	862	#define ecb_is_constant(expr) __builtin_constant_p (expr)
		863	#else
		864	/* possible C11 impl for integral types
		865	typedef struct ecb_is_constant_struct ecb_is_constant_struct;
		866	#define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
		867
		868	#define ecb_is_constant(expr) 0
		869	#endif
		870
		871	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
670	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))	872	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
		873	#else
		874	#define ecb_expect(expr,value) (expr)
		875	#endif
		876
		877	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
671	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)	878	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
672	#else	879	#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)	880	#define ecb_prefetch(addr,rw,locality)
677	#endif	881	#endif
678		882
679	/* no emulation for ecb_decltype */	883	/* no emulation for ecb_decltype */
680	#if ECB_GCC_VERSION(4,5)	884	#if ECB_CPP11
		885	// older implementations might have problems with decltype(x)::type, work around it
		886	template<class T> struct ecb_decltype_t { typedef T type; };
681	#define ecb_decltype(x) __decltype(x)	887	#define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
682	#elif ECB_GCC_VERSION(3,0)	888	#elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
683	#define ecb_decltype(x) __typeof(x)	889	#define ecb_decltype(x) __typeof__ (x)
684	#endif	890	#endif
685		891
		892	#if _MSC_VER >= 1300
		893	#define ecb_deprecated __declspec (deprecated)
		894	#else
		895	#define ecb_deprecated ecb_attribute ((__deprecated__))
		896	#endif
		897
		898	#if _MSC_VER >= 1500
		899	#define ecb_deprecated_message(msg) __declspec (deprecated (msg))
		900	#elif ECB_GCC_VERSION(4,5)
		901	#define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg))
		902	#else
		903	#define ecb_deprecated_message(msg) ecb_deprecated
		904	#endif
		905
		906	#if _MSC_VER >= 1400
		907	#define ecb_noinline __declspec (noinline)
		908	#else
686	#define ecb_noinline ecb_attribute ((__noinline__))	909	#define ecb_noinline ecb_attribute ((__noinline__))
687	#define ecb_noreturn ecb_attribute ((__noreturn__))	910	#endif
		911
688	#define ecb_unused ecb_attribute ((__unused__))	912	#define ecb_unused ecb_attribute ((__unused__))
689	#define ecb_const ecb_attribute ((__const__))	913	#define ecb_const ecb_attribute ((__const__))
690	#define ecb_pure ecb_attribute ((__pure__))	914	#define ecb_pure ecb_attribute ((__pure__))
		915
		916	#if ECB_C11 || __IBMC_NORETURN
		917	/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/language_ref/noreturn.html */
		918	#define ecb_noreturn _Noreturn
		919	#elif ECB_CPP11
		920	#define ecb_noreturn [[noreturn]]
		921	#elif _MSC_VER >= 1200
		922	/* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */
		923	#define ecb_noreturn __declspec (noreturn)
		924	#else
		925	#define ecb_noreturn ecb_attribute ((__noreturn__))
		926	#endif
691		927
692	#if ECB_GCC_VERSION(4,3)	928	#if ECB_GCC_VERSION(4,3)
693	#define ecb_artificial ecb_attribute ((__artificial__))	929	#define ecb_artificial ecb_attribute ((__artificial__))
694	#define ecb_hot ecb_attribute ((__hot__))	930	#define ecb_hot ecb_attribute ((__hot__))
695	#define ecb_cold ecb_attribute ((__cold__))	931	#define ecb_cold ecb_attribute ((__cold__))
…		…
707	/* for compatibility to the rest of the world */	943	/* for compatibility to the rest of the world */
708	#define ecb_likely(expr) ecb_expect_true (expr)	944	#define ecb_likely(expr) ecb_expect_true (expr)
709	#define ecb_unlikely(expr) ecb_expect_false (expr)	945	#define ecb_unlikely(expr) ecb_expect_false (expr)
710		946
711	/* count trailing zero bits and count # of one bits */	947	/* count trailing zero bits and count # of one bits */
712	#if ECB_GCC_VERSION(3,4)	948	#if ECB_GCC_VERSION(3,4) \
		949	|| (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
		950	&& ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
		951	&& ECB_CLANG_BUILTIN(__builtin_popcount))
713	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */	952	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
714	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)	953	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)
715	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)	954	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
716	#define ecb_ctz32(x) __builtin_ctz (x)	955	#define ecb_ctz32(x) __builtin_ctz (x)
717	#define ecb_ctz64(x) __builtin_ctzll (x)	956	#define ecb_ctz64(x) __builtin_ctzll (x)
718	#define ecb_popcount32(x) __builtin_popcount (x)	957	#define ecb_popcount32(x) __builtin_popcount (x)
719	/* no popcountll */	958	/* no popcountll */
720	#else	959	#else
721	ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;	960	ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
722	ecb_function_ int	961	ecb_function_ ecb_const int
723	ecb_ctz32 (uint32_t x)	962	ecb_ctz32 (uint32_t x)
724	{	963	{
		964	#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
		965	unsigned long r;
		966	_BitScanForward (&r, x);
		967	return (int)r;
		968	#else
725	int r = 0;	969	int r = 0;
726		970
727	x &= ~x + 1; /* this isolates the lowest bit */	971	x &= ~x + 1; /* this isolates the lowest bit */
728		972
729	#if ECB_branchless_on_i386	973	#if ECB_branchless_on_i386
…		…
739	if (x & 0xff00ff00) r += 8;	983	if (x & 0xff00ff00) r += 8;
740	if (x & 0xffff0000) r += 16;	984	if (x & 0xffff0000) r += 16;
741	#endif	985	#endif
742		986
743	return r;	987	return r;
		988	#endif
744	}	989	}
745		990
746	ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;	991	ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
747	ecb_function_ int	992	ecb_function_ ecb_const int
748	ecb_ctz64 (uint64_t x)	993	ecb_ctz64 (uint64_t x)
749	{	994	{
		995	#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
		996	unsigned long r;
		997	_BitScanForward64 (&r, x);
		998	return (int)r;
		999	#else
750	int shift = x & 0xffffffffU ? 0 : 32;	1000	int shift = x & 0xffffffff ? 0 : 32;
751	return ecb_ctz32 (x >> shift) + shift;	1001	return ecb_ctz32 (x >> shift) + shift;
		1002	#endif
752	}	1003	}
753		1004
754	ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;	1005	ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
755	ecb_function_ int	1006	ecb_function_ ecb_const int
756	ecb_popcount32 (uint32_t x)	1007	ecb_popcount32 (uint32_t x)
757	{	1008	{
758	x -= (x >> 1) & 0x55555555;	1009	x -= (x >> 1) & 0x55555555;
759	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);	1010	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
760	x = ((x >> 4) + x) & 0x0f0f0f0f;	1011	x = ((x >> 4) + x) & 0x0f0f0f0f;
761	x *= 0x01010101;	1012	x *= 0x01010101;
762		1013
763	return x >> 24;	1014	return x >> 24;
764	}	1015	}
765		1016
766	ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;	1017	ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
767	ecb_function_ int ecb_ld32 (uint32_t x)	1018	ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
768	{	1019	{
		1020	#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
		1021	unsigned long r;
		1022	_BitScanReverse (&r, x);
		1023	return (int)r;
		1024	#else
769	int r = 0;	1025	int r = 0;
770		1026
771	if (x >> 16) { x >>= 16; r += 16; }	1027	if (x >> 16) { x >>= 16; r += 16; }
772	if (x >> 8) { x >>= 8; r += 8; }	1028	if (x >> 8) { x >>= 8; r += 8; }
773	if (x >> 4) { x >>= 4; r += 4; }	1029	if (x >> 4) { x >>= 4; r += 4; }
774	if (x >> 2) { x >>= 2; r += 2; }	1030	if (x >> 2) { x >>= 2; r += 2; }
775	if (x >> 1) { r += 1; }	1031	if (x >> 1) { r += 1; }
776		1032
777	return r;	1033	return r;
		1034	#endif
778	}	1035	}
779		1036
780	ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;	1037	ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
781	ecb_function_ int ecb_ld64 (uint64_t x)	1038	ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
782	{	1039	{
		1040	#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
		1041	unsigned long r;
		1042	_BitScanReverse64 (&r, x);
		1043	return (int)r;
		1044	#else
783	int r = 0;	1045	int r = 0;
784		1046
785	if (x >> 32) { x >>= 32; r += 32; }	1047	if (x >> 32) { x >>= 32; r += 32; }
786		1048
787	return r + ecb_ld32 (x);	1049	return r + ecb_ld32 (x);
		1050	#endif
788	}	1051	}
789	#endif	1052	#endif
790		1053
		1054	ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
		1055	ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
		1056	ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
		1057	ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
		1058
791	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;	1059	ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
792	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)	1060	ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
793	{	1061	{
794	return ( (x * 0x0802U & 0x22110U)	1062	return ( (x * 0x0802U & 0x22110U)
795	| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;	1063	| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
796	}	1064	}
797		1065
798	ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;	1066	ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
799	ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)	1067	ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
800	{	1068	{
801	x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);	1069	x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
802	x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);	1070	x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
803	x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);	1071	x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
804	x = ( x >> 8 ) | ( x << 8);	1072	x = ( x >> 8 ) | ( x << 8);
805		1073
806	return x;	1074	return x;
807	}	1075	}
808		1076
809	ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;	1077	ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
810	ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)	1078	ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
811	{	1079	{
812	x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);	1080	x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
813	x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);	1081	x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
814	x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);	1082	x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
815	x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);	1083	x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
…		…
818	return x;	1086	return x;
819	}	1087	}
820		1088
821	/* popcount64 is only available on 64 bit cpus as gcc builtin */	1089	/* popcount64 is only available on 64 bit cpus as gcc builtin */
822	/* so for this version we are lazy */	1090	/* so for this version we are lazy */
823	ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;	1091	ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
824	ecb_function_ int	1092	ecb_function_ ecb_const int
825	ecb_popcount64 (uint64_t x)	1093	ecb_popcount64 (uint64_t x)
826	{	1094	{
827	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);	1095	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
828	}	1096	}
829		1097
830	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;	1098	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;	1099	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;	1100	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;	1101	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;	1102	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;	1103	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;	1104	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;	1105	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
838		1106
839	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }	1107	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); }	1108	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); }	1109	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); }	1110	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); }	1111	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); }	1112	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); }	1113	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); }	1114	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
847		1115
848	#if ECB_GCC_VERSION(4,3)	1116	#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
		1117	#if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
		1118	#define ecb_bswap16(x) __builtin_bswap16 (x)
		1119	#else
849	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)	1120	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
		1121	#endif
850	#define ecb_bswap32(x) __builtin_bswap32 (x)	1122	#define ecb_bswap32(x) __builtin_bswap32 (x)
851	#define ecb_bswap64(x) __builtin_bswap64 (x)	1123	#define ecb_bswap64(x) __builtin_bswap64 (x)
		1124	#elif _MSC_VER
		1125	#include <stdlib.h>
		1126	#define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
		1127	#define ecb_bswap32(x) ((uint32_t)_byteswap_ulong ((uint32_t)(x)))
		1128	#define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
852	#else	1129	#else
853	ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;	1130	ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
854	ecb_function_ uint16_t	1131	ecb_function_ ecb_const uint16_t
855	ecb_bswap16 (uint16_t x)	1132	ecb_bswap16 (uint16_t x)
856	{	1133	{
857	return ecb_rotl16 (x, 8);	1134	return ecb_rotl16 (x, 8);
858	}	1135	}
859		1136
860	ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;	1137	ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
861	ecb_function_ uint32_t	1138	ecb_function_ ecb_const uint32_t
862	ecb_bswap32 (uint32_t x)	1139	ecb_bswap32 (uint32_t x)
863	{	1140	{
864	return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);	1141	return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
865	}	1142	}
866		1143
867	ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;	1144	ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
868	ecb_function_ uint64_t	1145	ecb_function_ ecb_const uint64_t
869	ecb_bswap64 (uint64_t x)	1146	ecb_bswap64 (uint64_t x)
870	{	1147	{
871	return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);	1148	return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
872	}	1149	}
873	#endif	1150	#endif
874		1151
875	#if ECB_GCC_VERSION(4,5)	1152	#if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
876	#define ecb_unreachable() __builtin_unreachable ()	1153	#define ecb_unreachable() __builtin_unreachable ()
877	#else	1154	#else
878	/* this seems to work fine, but gcc always emits a warning for it :/ */	1155	/* this seems to work fine, but gcc always emits a warning for it :/ */
879	ecb_inline void ecb_unreachable (void) ecb_noreturn;	1156	ecb_inline ecb_noreturn void ecb_unreachable (void);
880	ecb_inline void ecb_unreachable (void) { }	1157	ecb_inline ecb_noreturn void ecb_unreachable (void) { }
881	#endif	1158	#endif
882		1159
883	/* try to tell the compiler that some condition is definitely true */	1160	/* try to tell the compiler that some condition is definitely true */
884	#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)	1161	#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
885		1162
886	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;	1163	ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
887	ecb_inline unsigned char	1164	ecb_inline ecb_const uint32_t
888	ecb_byteorder_helper (void)	1165	ecb_byteorder_helper (void)
889	{	1166	{
890	const uint32_t u = 0x11223344;	1167	/* the union code still generates code under pressure in gcc, */
891	return *(unsigned char *)&u;	1168	/* but less than using pointers, and always seems to */
		1169	/* successfully return a constant. */
		1170	/* the reason why we have this horrible preprocessor mess */
		1171	/* is to avoid it in all cases, at least on common architectures */
		1172	/* or when using a recent enough gcc version (>= 4.6) */
		1173	#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
		1174	|| ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
		1175	#define ECB_LITTLE_ENDIAN 1
		1176	return 0x44332211;
		1177	#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
		1178	|| ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
		1179	#define ECB_BIG_ENDIAN 1
		1180	return 0x11223344;
		1181	#else
		1182	union
		1183	{
		1184	uint8_t c[4];
		1185	uint32_t u;
		1186	} u = { 0x11, 0x22, 0x33, 0x44 };
		1187	return u.u;
		1188	#endif
892	}	1189	}
893		1190
894	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;	1191	ecb_inline ecb_const ecb_bool ecb_big_endian (void);
895	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }	1192	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;	1193	ecb_inline ecb_const ecb_bool ecb_little_endian (void);
897	ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }	1194	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
898		1195
899	#if ECB_GCC_VERSION(3,0) || ECB_C99	1196	#if ECB_GCC_VERSION(3,0) || ECB_C99
900	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))	1197	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
901	#else	1198	#else
902	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))	1199	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
903	#endif	1200	#endif
904		1201
905	#if __cplusplus	1202	#if ECB_CPP
906	template<typename T>	1203	template<typename T>
907	static inline T ecb_div_rd (T val, T div)	1204	static inline T ecb_div_rd (T val, T div)
908	{	1205	{
909	return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;	1206	return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
910	}	1207	}
…		…
927	}	1224	}
928	#else	1225	#else
929	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	1226	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
930	#endif	1227	#endif
931		1228
		1229	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
		1230	ecb_function_ ecb_const uint32_t
		1231	ecb_binary16_to_binary32 (uint32_t x)
		1232	{
		1233	unsigned int s = (x & 0x8000) << (31 - 15);
		1234	int e = (x >> 10) & 0x001f;
		1235	unsigned int m = x & 0x03ff;
		1236
		1237	if (ecb_expect_false (e == 31))
		1238	/* infinity or NaN */
		1239	e = 255 - (127 - 15);
		1240	else if (ecb_expect_false (!e))
		1241	{
		1242	if (ecb_expect_true (!m))
		1243	/* zero, handled by code below by forcing e to 0 */
		1244	e = 0 - (127 - 15);
		1245	else
		1246	{
		1247	/* subnormal, renormalise */
		1248	unsigned int s = 10 - ecb_ld32 (m);
		1249
		1250	m = (m << s) & 0x3ff; /* mask implicit bit */
		1251	e -= s - 1;
		1252	}
		1253	}
		1254
		1255	/* e and m now are normalised, or zero, (or inf or nan) */
		1256	e += 127 - 15;
		1257
		1258	return s | (e << 23) | (m << (23 - 10));
		1259	}
		1260
		1261	ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
		1262	ecb_function_ ecb_const uint16_t
		1263	ecb_binary32_to_binary16 (uint32_t x)
		1264	{
		1265	unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
		1266	unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
		1267	unsigned int m = x & 0x007fffff;
		1268
		1269	x &= 0x7fffffff;
		1270
		1271	/* if it's within range of binary16 normals, use fast path */
		1272	if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
		1273	{
		1274	/* mantissa round-to-even */
		1275	m += 0x00000fff + ((m >> (23 - 10)) & 1);
		1276
		1277	/* handle overflow */
		1278	if (ecb_expect_false (m >= 0x00800000))
		1279	{
		1280	m >>= 1;
		1281	e += 1;
		1282	}
		1283
		1284	return s | (e << 10) | (m >> (23 - 10));
		1285	}
		1286
		1287	/* handle large numbers and infinity */
		1288	if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
		1289	return s | 0x7c00;
		1290
		1291	/* handle zero, subnormals and small numbers */
		1292	if (ecb_expect_true (x < 0x38800000))
		1293	{
		1294	/* zero */
		1295	if (ecb_expect_true (!x))
		1296	return s;
		1297
		1298	/* handle subnormals */
		1299
		1300	/* too small, will be zero */
		1301	if (e < (14 - 24)) /* might not be sharp, but is good enough */
		1302	return s;
		1303
		1304	m |= 0x00800000; /* make implicit bit explicit */
		1305
		1306	/* very tricky - we need to round to the nearest e (+10) bit value */
		1307	{
		1308	unsigned int bits = 14 - e;
		1309	unsigned int half = (1 << (bits - 1)) - 1;
		1310	unsigned int even = (m >> bits) & 1;
		1311
		1312	/* if this overflows, we will end up with a normalised number */
		1313	m = (m + half + even) >> bits;
		1314	}
		1315
		1316	return s | m;
		1317	}
		1318
		1319	/* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
		1320	m >>= 13;
		1321
		1322	return s | 0x7c00 | m | !m;
		1323	}
		1324
		1325	/*******************************************************************************/
		1326	/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
		1327
		1328	/* basically, everything uses "ieee pure-endian" floating point numbers */
		1329	/* the only noteworthy exception is ancient armle, which uses order 43218765 */
		1330	#if 0 \
		1331	|| __i386 || __i386__ \
		1332	|| ECB_GCC_AMD64 \
		1333	|| __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
		1334	|| defined __s390__ || defined __s390x__ \
		1335	|| defined __mips__ \
		1336	|| defined __alpha__ \
		1337	|| defined __hppa__ \
		1338	|| defined __ia64__ \
		1339	|| defined __m68k__ \
		1340	|| defined __m88k__ \
		1341	|| defined __sh__ \
		1342	|| defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
		1343	|| (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
		1344	|| defined __aarch64__
		1345	#define ECB_STDFP 1
		1346	#include <string.h> /* for memcpy */
		1347	#else
		1348	#define ECB_STDFP 0
		1349	#endif
		1350
		1351	#ifndef ECB_NO_LIBM
		1352
		1353	#include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
		1354
		1355	/* only the oldest of old doesn't have this one. solaris. */
		1356	#ifdef INFINITY
		1357	#define ECB_INFINITY INFINITY
		1358	#else
		1359	#define ECB_INFINITY HUGE_VAL
		1360	#endif
		1361
		1362	#ifdef NAN
		1363	#define ECB_NAN NAN
		1364	#else
		1365	#define ECB_NAN ECB_INFINITY
		1366	#endif
		1367
		1368	#if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
		1369	#define ecb_ldexpf(x,e) ldexpf ((x), (e))
		1370	#define ecb_frexpf(x,e) frexpf ((x), (e))
		1371	#else
		1372	#define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
		1373	#define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
		1374	#endif
		1375
		1376	/* convert a float to ieee single/binary32 */
		1377	ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
		1378	ecb_function_ ecb_const uint32_t
		1379	ecb_float_to_binary32 (float x)
		1380	{
		1381	uint32_t r;
		1382
		1383	#if ECB_STDFP
		1384	memcpy (&r, &x, 4);
		1385	#else
		1386	/* slow emulation, works for anything but -0 */
		1387	uint32_t m;
		1388	int e;
		1389
		1390	if (x == 0e0f ) return 0x00000000U;
		1391	if (x > +3.40282346638528860e+38f) return 0x7f800000U;
		1392	if (x < -3.40282346638528860e+38f) return 0xff800000U;
		1393	if (x != x ) return 0x7fbfffffU;
		1394
		1395	m = ecb_frexpf (x, &e) * 0x1000000U;
		1396
		1397	r = m & 0x80000000U;
		1398
		1399	if (r)
		1400	m = -m;
		1401
		1402	if (e <= -126)
		1403	{
		1404	m &= 0xffffffU;
		1405	m >>= (-125 - e);
		1406	e = -126;
		1407	}
		1408
		1409	r |= (e + 126) << 23;
		1410	r |= m & 0x7fffffU;
		1411	#endif
		1412
		1413	return r;
		1414	}
		1415
		1416	/* converts an ieee single/binary32 to a float */
		1417	ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
		1418	ecb_function_ ecb_const float
		1419	ecb_binary32_to_float (uint32_t x)
		1420	{
		1421	float r;
		1422
		1423	#if ECB_STDFP
		1424	memcpy (&r, &x, 4);
		1425	#else
		1426	/* emulation, only works for normals and subnormals and +0 */
		1427	int neg = x >> 31;
		1428	int e = (x >> 23) & 0xffU;
		1429
		1430	x &= 0x7fffffU;
		1431
		1432	if (e)
		1433	x |= 0x800000U;
		1434	else
		1435	e = 1;
		1436
		1437	/* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
		1438	r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
		1439
		1440	r = neg ? -r : r;
		1441	#endif
		1442
		1443	return r;
		1444	}
		1445
		1446	/* convert a double to ieee double/binary64 */
		1447	ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
		1448	ecb_function_ ecb_const uint64_t
		1449	ecb_double_to_binary64 (double x)
		1450	{
		1451	uint64_t r;
		1452
		1453	#if ECB_STDFP
		1454	memcpy (&r, &x, 8);
		1455	#else
		1456	/* slow emulation, works for anything but -0 */
		1457	uint64_t m;
		1458	int e;
		1459
		1460	if (x == 0e0 ) return 0x0000000000000000U;
		1461	if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
		1462	if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
		1463	if (x != x ) return 0X7ff7ffffffffffffU;
		1464
		1465	m = frexp (x, &e) * 0x20000000000000U;
		1466
		1467	r = m & 0x8000000000000000;;
		1468
		1469	if (r)
		1470	m = -m;
		1471
		1472	if (e <= -1022)
		1473	{
		1474	m &= 0x1fffffffffffffU;
		1475	m >>= (-1021 - e);
		1476	e = -1022;
		1477	}
		1478
		1479	r |= ((uint64_t)(e + 1022)) << 52;
		1480	r |= m & 0xfffffffffffffU;
		1481	#endif
		1482
		1483	return r;
		1484	}
		1485
		1486	/* converts an ieee double/binary64 to a double */
		1487	ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
		1488	ecb_function_ ecb_const double
		1489	ecb_binary64_to_double (uint64_t x)
		1490	{
		1491	double r;
		1492
		1493	#if ECB_STDFP
		1494	memcpy (&r, &x, 8);
		1495	#else
		1496	/* emulation, only works for normals and subnormals and +0 */
		1497	int neg = x >> 63;
		1498	int e = (x >> 52) & 0x7ffU;
		1499
		1500	x &= 0xfffffffffffffU;
		1501
		1502	if (e)
		1503	x |= 0x10000000000000U;
		1504	else
		1505	e = 1;
		1506
		1507	/* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
		1508	r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
		1509
		1510	r = neg ? -r : r;
		1511	#endif
		1512
		1513	return r;
		1514	}
		1515
		1516	/* convert a float to ieee half/binary16 */
		1517	ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
		1518	ecb_function_ ecb_const uint16_t
		1519	ecb_float_to_binary16 (float x)
		1520	{
		1521	return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
		1522	}
		1523
		1524	/* convert an ieee half/binary16 to float */
		1525	ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
		1526	ecb_function_ ecb_const float
		1527	ecb_binary16_to_float (uint16_t x)
		1528	{
		1529	return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
		1530	}
		1531
		1532	#endif
		1533
932	#endif	1534	#endif
933		1535
934	/* ECB.H END */	1536	/* ECB.H END */
935		1537
936	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1538	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
…		…
957	#define inline_size ecb_inline	1559	#define inline_size ecb_inline
958		1560
959	#if EV_FEATURE_CODE	1561	#if EV_FEATURE_CODE
960	# define inline_speed ecb_inline	1562	# define inline_speed ecb_inline
961	#else	1563	#else
962	# define inline_speed static noinline	1564	# define inline_speed noinline static
963	#endif	1565	#endif
964		1566
965	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1567	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
966		1568
967	#if EV_MINPRI == EV_MAXPRI	1569	#if EV_MINPRI == EV_MAXPRI
968	# define ABSPRI(w) (((W)w), 0)	1570	# define ABSPRI(w) (((W)w), 0)
969	#else	1571	#else
970	# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)	1572	# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
971	#endif	1573	#endif
972		1574
973	#define EMPTY /* required for microsofts broken pseudo-c compiler */	1575	#define EMPTY /* required for microsofts broken pseudo-c compiler */
974	#define EMPTY2(a,b) /* used to suppress some warnings */
975		1576
976	typedef ev_watcher *W;	1577	typedef ev_watcher *W;
977	typedef ev_watcher_list *WL;	1578	typedef ev_watcher_list *WL;
978	typedef ev_watcher_time *WT;	1579	typedef ev_watcher_time *WT;
979		1580
…		…
1004	# include "ev_win32.c"	1605	# include "ev_win32.c"
1005	#endif	1606	#endif
1006		1607
1007	/*****************************************************************************/	1608	/*****************************************************************************/
1008		1609
		1610	#if EV_USE_LINUXAIO
		1611	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
		1612	#endif
		1613
1009	/* define a suitable floor function (only used by periodics atm) */	1614	/* define a suitable floor function (only used by periodics atm) */
1010		1615
1011	#if EV_USE_FLOOR	1616	#if EV_USE_FLOOR
1012	# include <math.h>	1617	# include <math.h>
1013	# define ev_floor(v) floor (v)	1618	# define ev_floor(v) floor (v)
1014	#else	1619	#else
1015		1620
1016	#include <float.h>	1621	#include <float.h>
1017		1622
1018	/* a floor() replacement function, should be independent of ev_tstamp type */	1623	/* a floor() replacement function, should be independent of ev_tstamp type */
		1624	noinline
1019	static ev_tstamp noinline	1625	static ev_tstamp
1020	ev_floor (ev_tstamp v)	1626	ev_floor (ev_tstamp v)
1021	{	1627	{
1022	/* the choice of shift factor is not terribly important */	1628	/* the choice of shift factor is not terribly important */
1023	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1629	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1024	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1630	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
…		…
1056		1662
1057	#ifdef __linux	1663	#ifdef __linux
1058	# include <sys/utsname.h>	1664	# include <sys/utsname.h>
1059	#endif	1665	#endif
1060		1666
1061	static unsigned int noinline ecb_cold	1667	noinline ecb_cold
		1668	static unsigned int
1062	ev_linux_version (void)	1669	ev_linux_version (void)
1063	{	1670	{
1064	#ifdef __linux	1671	#ifdef __linux
1065	unsigned int v = 0;	1672	unsigned int v = 0;
1066	struct utsname buf;	1673	struct utsname buf;
…		…
1095	}	1702	}
1096		1703
1097	/*****************************************************************************/	1704	/*****************************************************************************/
1098		1705
1099	#if EV_AVOID_STDIO	1706	#if EV_AVOID_STDIO
1100	static void noinline ecb_cold	1707	noinline ecb_cold
		1708	static void
1101	ev_printerr (const char *msg)	1709	ev_printerr (const char *msg)
1102	{	1710	{
1103	write (STDERR_FILENO, msg, strlen (msg));	1711	write (STDERR_FILENO, msg, strlen (msg));
1104	}	1712	}
1105	#endif	1713	#endif
1106		1714
1107	static void (*syserr_cb)(const char *msg) EV_THROW;	1715	static void (*syserr_cb)(const char *msg) EV_NOEXCEPT;
1108		1716
1109	void ecb_cold	1717	ecb_cold
		1718	void
1110	ev_set_syserr_cb (void (*cb)(const char *msg)) EV_THROW	1719	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
1111	{	1720	{
1112	syserr_cb = cb;	1721	syserr_cb = cb;
1113	}	1722	}
1114		1723
1115	static void noinline ecb_cold	1724	noinline ecb_cold
		1725	static void
1116	ev_syserr (const char *msg)	1726	ev_syserr (const char *msg)
1117	{	1727	{
1118	if (!msg)	1728	if (!msg)
1119	msg = "(libev) system error";	1729	msg = "(libev) system error";
1120		1730
…		…
1133	abort ();	1743	abort ();
1134	}	1744	}
1135	}	1745	}
1136		1746
1137	static void *	1747	static void *
1138	ev_realloc_emul (void *ptr, long size)	1748	ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
1139	{	1749	{
1140	#if __GLIBC__
1141	return realloc (ptr, size);
1142	#else
1143	/* some systems, notably openbsd and darwin, fail to properly	1750	/* some systems, notably openbsd and darwin, fail to properly
1144	* implement realloc (x, 0) (as required by both ansi c-89 and	1751	* implement realloc (x, 0) (as required by both ansi c-89 and
1145	* the single unix specification, so work around them here.	1752	* the single unix specification, so work around them here.
		1753	* recently, also (at least) fedora and debian started breaking it,
		1754	* despite documenting it otherwise.
1146	*/	1755	*/
1147		1756
1148	if (size)	1757	if (size)
1149	return realloc (ptr, size);	1758	return realloc (ptr, size);
1150		1759
1151	free (ptr);	1760	free (ptr);
1152	return 0;	1761	return 0;
1153	#endif
1154	}	1762	}
1155		1763
1156	static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;	1764	static void *(*alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul;
1157		1765
1158	void ecb_cold	1766	ecb_cold
		1767	void
1159	ev_set_allocator (void *(*cb)(void *ptr, long size)) EV_THROW	1768	ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT
1160	{	1769	{
1161	alloc = cb;	1770	alloc = cb;
1162	}	1771	}
1163		1772
1164	inline_speed void *	1773	inline_speed void *
…		…
1191	typedef struct	1800	typedef struct
1192	{	1801	{
1193	WL head;	1802	WL head;
1194	unsigned char events; /* the events watched for */	1803	unsigned char events; /* the events watched for */
1195	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */	1804	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 */	1805	unsigned char emask; /* some backends store the actual kernel mask in here */
1197	unsigned char unused;	1806	unsigned char unused;
1198	#if EV_USE_EPOLL	1807	#if EV_USE_EPOLL
1199	unsigned int egen; /* generation counter to counter epoll bugs */	1808	unsigned int egen; /* generation counter to counter epoll bugs */
1200	#endif	1809	#endif
1201	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	1810	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
…		…
1281		1890
1282	/*****************************************************************************/	1891	/*****************************************************************************/
1283		1892
1284	#ifndef EV_HAVE_EV_TIME	1893	#ifndef EV_HAVE_EV_TIME
1285	ev_tstamp	1894	ev_tstamp
1286	ev_time (void) EV_THROW	1895	ev_time (void) EV_NOEXCEPT
1287	{	1896	{
1288	#if EV_USE_REALTIME	1897	#if EV_USE_REALTIME
1289	if (expect_true (have_realtime))	1898	if (expect_true (have_realtime))
1290	{	1899	{
1291	struct timespec ts;	1900	struct timespec ts;
…		…
1315	return ev_time ();	1924	return ev_time ();
1316	}	1925	}
1317		1926
1318	#if EV_MULTIPLICITY	1927	#if EV_MULTIPLICITY
1319	ev_tstamp	1928	ev_tstamp
1320	ev_now (EV_P) EV_THROW	1929	ev_now (EV_P) EV_NOEXCEPT
1321	{	1930	{
1322	return ev_rt_now;	1931	return ev_rt_now;
1323	}	1932	}
1324	#endif	1933	#endif
1325		1934
1326	void	1935	void
1327	ev_sleep (ev_tstamp delay) EV_THROW	1936	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1328	{	1937	{
1329	if (delay > 0.)	1938	if (delay > 0.)
1330	{	1939	{
1331	#if EV_USE_NANOSLEEP	1940	#if EV_USE_NANOSLEEP
1332	struct timespec ts;	1941	struct timespec ts;
1333		1942
1334	EV_TS_SET (ts, delay);	1943	EV_TS_SET (ts, delay);
1335	nanosleep (&ts, 0);	1944	nanosleep (&ts, 0);
1336	#elif defined _WIN32	1945	#elif defined _WIN32
		1946	/* maybe this should round up, as ms is very low resolution */
		1947	/* compared to select (µs) or nanosleep (ns) */
1337	Sleep ((unsigned long)(delay * 1e3));	1948	Sleep ((unsigned long)(delay * 1e3));
1338	#else	1949	#else
1339	struct timeval tv;	1950	struct timeval tv;
1340		1951
1341	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */	1952	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
…		…
1372	}	1983	}
1373		1984
1374	return ncur;	1985	return ncur;
1375	}	1986	}
1376		1987
1377	static void * noinline ecb_cold	1988	noinline ecb_cold
		1989	static void *
1378	array_realloc (int elem, void *base, int *cur, int cnt)	1990	array_realloc (int elem, void *base, int *cur, int cnt)
1379	{	1991	{
1380	*cur = array_nextsize (elem, *cur, cnt);	1992	*cur = array_nextsize (elem, *cur, cnt);
1381	return ev_realloc (base, elem * *cur);	1993	return ev_realloc (base, elem * *cur);
1382	}	1994	}
1383		1995
		1996	#define array_needsize_noinit(base,offset,count)
		1997
1384	#define array_init_zero(base,count) \	1998	#define array_needsize_zerofill(base,offset,count) \
1385	memset ((void *)(base), 0, sizeof (*(base)) * (count))	1999	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
1386		2000
1387	#define array_needsize(type,base,cur,cnt,init) \	2001	#define array_needsize(type,base,cur,cnt,init) \
1388	if (expect_false ((cnt) > (cur))) \	2002	if (expect_false ((cnt) > (cur))) \
1389	{ \	2003	{ \
1390	int ecb_unused ocur_ = (cur); \	2004	ecb_unused int ocur_ = (cur); \
1391	(base) = (type *)array_realloc \	2005	(base) = (type *)array_realloc \
1392	(sizeof (type), (base), &(cur), (cnt)); \	2006	(sizeof (type), (base), &(cur), (cnt)); \
1393	init ((base) + (ocur_), (cur) - ocur_); \	2007	init ((base), ocur_, ((cur) - ocur_)); \
1394	}	2008	}
1395		2009
1396	#if 0	2010	#if 0
1397	#define array_slim(type,stem) \	2011	#define array_slim(type,stem) \
1398	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \	2012	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	2021	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1408		2022
1409	/*****************************************************************************/	2023	/*****************************************************************************/
1410		2024
1411	/* dummy callback for pending events */	2025	/* dummy callback for pending events */
1412	static void noinline	2026	noinline
		2027	static void
1413	pendingcb (EV_P_ ev_prepare *w, int revents)	2028	pendingcb (EV_P_ ev_prepare *w, int revents)
1414	{	2029	{
1415	}	2030	}
1416		2031
1417	void noinline	2032	noinline
		2033	void
1418	ev_feed_event (EV_P_ void *w, int revents) EV_THROW	2034	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
1419	{	2035	{
1420	W w_ = (W)w;	2036	W w_ = (W)w;
1421	int pri = ABSPRI (w_);	2037	int pri = ABSPRI (w_);
1422		2038
1423	if (expect_false (w_->pending))	2039	if (expect_false (w_->pending))
1424	pendings [pri][w_->pending - 1].events |= revents;	2040	pendings [pri][w_->pending - 1].events |= revents;
1425	else	2041	else
1426	{	2042	{
1427	w_->pending = ++pendingcnt [pri];	2043	w_->pending = ++pendingcnt [pri];
1428	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);	2044	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);
1429	pendings [pri][w_->pending - 1].w = w_;	2045	pendings [pri][w_->pending - 1].w = w_;
1430	pendings [pri][w_->pending - 1].events = revents;	2046	pendings [pri][w_->pending - 1].events = revents;
1431	}	2047	}
1432		2048
1433	pendingpri = NUMPRI - 1;	2049	pendingpri = NUMPRI - 1;
1434	}	2050	}
1435		2051
1436	inline_speed void	2052	inline_speed void
1437	feed_reverse (EV_P_ W w)	2053	feed_reverse (EV_P_ W w)
1438	{	2054	{
1439	array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);	2055	array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, array_needsize_noinit);
1440	rfeeds [rfeedcnt++] = w;	2056	rfeeds [rfeedcnt++] = w;
1441	}	2057	}
1442		2058
1443	inline_size void	2059	inline_size void
1444	feed_reverse_done (EV_P_ int revents)	2060	feed_reverse_done (EV_P_ int revents)
…		…
1484	if (expect_true (!anfd->reify))	2100	if (expect_true (!anfd->reify))
1485	fd_event_nocheck (EV_A_ fd, revents);	2101	fd_event_nocheck (EV_A_ fd, revents);
1486	}	2102	}
1487		2103
1488	void	2104	void
1489	ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW	2105	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
1490	{	2106	{
1491	if (fd >= 0 && fd < anfdmax)	2107	if (fd >= 0 && fd < anfdmax)
1492	fd_event_nocheck (EV_A_ fd, revents);	2108	fd_event_nocheck (EV_A_ fd, revents);
1493	}	2109	}
1494		2110
…		…
1531	ev_io *w;	2147	ev_io *w;
1532		2148
1533	unsigned char o_events = anfd->events;	2149	unsigned char o_events = anfd->events;
1534	unsigned char o_reify = anfd->reify;	2150	unsigned char o_reify = anfd->reify;
1535		2151
1536	anfd->reify = 0;	2152	anfd->reify = 0;
1537		2153
1538	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2154	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
1539	{	2155	{
1540	anfd->events = 0;	2156	anfd->events = 0;
1541		2157
…		…
1552		2168
1553	fdchangecnt = 0;	2169	fdchangecnt = 0;
1554	}	2170	}
1555		2171
1556	/* something about the given fd changed */	2172	/* something about the given fd changed */
1557	inline_size void	2173	inline_size
		2174	void
1558	fd_change (EV_P_ int fd, int flags)	2175	fd_change (EV_P_ int fd, int flags)
1559	{	2176	{
1560	unsigned char reify = anfds [fd].reify;	2177	unsigned char reify = anfds [fd].reify;
1561	anfds [fd].reify |= flags;	2178	anfds [fd].reify |= flags;
1562		2179
1563	if (expect_true (!reify))	2180	if (expect_true (!reify))
1564	{	2181	{
1565	++fdchangecnt;	2182	++fdchangecnt;
1566	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);	2183	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
1567	fdchanges [fdchangecnt - 1] = fd;	2184	fdchanges [fdchangecnt - 1] = fd;
1568	}	2185	}
1569	}	2186	}
1570		2187
1571	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */	2188	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
1572	inline_speed void ecb_cold	2189	inline_speed ecb_cold void
1573	fd_kill (EV_P_ int fd)	2190	fd_kill (EV_P_ int fd)
1574	{	2191	{
1575	ev_io *w;	2192	ev_io *w;
1576		2193
1577	while ((w = (ev_io *)anfds [fd].head))	2194	while ((w = (ev_io *)anfds [fd].head))
…		…
1580	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);	2197	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
1581	}	2198	}
1582	}	2199	}
1583		2200
1584	/* check whether the given fd is actually valid, for error recovery */	2201	/* check whether the given fd is actually valid, for error recovery */
1585	inline_size int ecb_cold	2202	inline_size ecb_cold int
1586	fd_valid (int fd)	2203	fd_valid (int fd)
1587	{	2204	{
1588	#ifdef _WIN32	2205	#ifdef _WIN32
1589	return EV_FD_TO_WIN32_HANDLE (fd) != -1;	2206	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
1590	#else	2207	#else
1591	return fcntl (fd, F_GETFD) != -1;	2208	return fcntl (fd, F_GETFD) != -1;
1592	#endif	2209	#endif
1593	}	2210	}
1594		2211
1595	/* called on EBADF to verify fds */	2212	/* called on EBADF to verify fds */
1596	static void noinline ecb_cold	2213	noinline ecb_cold
		2214	static void
1597	fd_ebadf (EV_P)	2215	fd_ebadf (EV_P)
1598	{	2216	{
1599	int fd;	2217	int fd;
1600		2218
1601	for (fd = 0; fd < anfdmax; ++fd)	2219	for (fd = 0; fd < anfdmax; ++fd)
…		…
1603	if (!fd_valid (fd) && errno == EBADF)	2221	if (!fd_valid (fd) && errno == EBADF)
1604	fd_kill (EV_A_ fd);	2222	fd_kill (EV_A_ fd);
1605	}	2223	}
1606		2224
1607	/* called on ENOMEM in select/poll to kill some fds and retry */	2225	/* called on ENOMEM in select/poll to kill some fds and retry */
1608	static void noinline ecb_cold	2226	noinline ecb_cold
		2227	static void
1609	fd_enomem (EV_P)	2228	fd_enomem (EV_P)
1610	{	2229	{
1611	int fd;	2230	int fd;
1612		2231
1613	for (fd = anfdmax; fd--; )	2232	for (fd = anfdmax; fd--; )
…		…
1617	break;	2236	break;
1618	}	2237	}
1619	}	2238	}
1620		2239
1621	/* usually called after fork if backend needs to re-arm all fds from scratch */	2240	/* usually called after fork if backend needs to re-arm all fds from scratch */
1622	static void noinline	2241	noinline
		2242	static void
1623	fd_rearm_all (EV_P)	2243	fd_rearm_all (EV_P)
1624	{	2244	{
1625	int fd;	2245	int fd;
1626		2246
1627	for (fd = 0; fd < anfdmax; ++fd)	2247	for (fd = 0; fd < anfdmax; ++fd)
…		…
1808		2428
1809	/*****************************************************************************/	2429	/*****************************************************************************/
1810		2430
1811	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2431	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
1812		2432
1813	static void noinline ecb_cold	2433	noinline ecb_cold
		2434	static void
1814	evpipe_init (EV_P)	2435	evpipe_init (EV_P)
1815	{	2436	{
1816	if (!ev_is_active (&pipe_w))	2437	if (!ev_is_active (&pipe_w))
1817	{	2438	{
		2439	int fds [2];
		2440
1818	# if EV_USE_EVENTFD	2441	# if EV_USE_EVENTFD
		2442	fds [0] = -1;
1819	evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);	2443	fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
1820	if (evfd < 0 && errno == EINVAL)	2444	if (fds [1] < 0 && errno == EINVAL)
1821	evfd = eventfd (0, 0);	2445	fds [1] = eventfd (0, 0);
1822		2446
1823	if (evfd >= 0)	2447	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	2448	# endif
1831	{	2449	{
1832	while (pipe (evpipe))	2450	while (pipe (fds))
1833	ev_syserr ("(libev) error creating signal/async pipe");	2451	ev_syserr ("(libev) error creating signal/async pipe");
1834		2452
1835	fd_intern (evpipe [0]);	2453	fd_intern (fds [0]);
1836	fd_intern (evpipe [1]);
1837	ev_io_set (&pipe_w, evpipe [0], EV_READ);
1838	}	2454	}
1839		2455
		2456	evpipe [0] = fds [0];
		2457
		2458	if (evpipe [1] < 0)
		2459	evpipe [1] = fds [1]; /* first call, set write fd */
		2460	else
		2461	{
		2462	/* on subsequent calls, do not change evpipe [1] */
		2463	/* so that evpipe_write can always rely on its value. */
		2464	/* this branch does not do anything sensible on windows, */
		2465	/* so must not be executed on windows */
		2466
		2467	dup2 (fds [1], evpipe [1]);
		2468	close (fds [1]);
		2469	}
		2470
		2471	fd_intern (evpipe [1]);
		2472
		2473	ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
1840	ev_io_start (EV_A_ &pipe_w);	2474	ev_io_start (EV_A_ &pipe_w);
1841	ev_unref (EV_A); /* watcher should not keep loop alive */	2475	ev_unref (EV_A); /* watcher should not keep loop alive */
1842	}	2476	}
1843	}	2477	}
1844		2478
…		…
1849		2483
1850	if (expect_true (*flag))	2484	if (expect_true (*flag))
1851	return;	2485	return;
1852		2486
1853	*flag = 1;	2487	*flag = 1;
1854
1855	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */	2488	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
1856		2489
1857	pipe_write_skipped = 1;	2490	pipe_write_skipped = 1;
1858		2491
1859	ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */	2492	ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
1860		2493
1861	if (pipe_write_wanted)	2494	if (pipe_write_wanted)
1862	{	2495	{
1863	int old_errno;	2496	int old_errno;
1864		2497
1865	pipe_write_skipped = 0; /* just an optimisation, no fence needed */	2498	pipe_write_skipped = 0;
		2499	ECB_MEMORY_FENCE_RELEASE;
1866		2500
1867	old_errno = errno; /* save errno because write will clobber it */	2501	old_errno = errno; /* save errno because write will clobber it */
1868		2502
1869	#if EV_USE_EVENTFD	2503	#if EV_USE_EVENTFD
1870	if (evfd >= 0)	2504	if (evpipe [0] < 0)
1871	{	2505	{
1872	uint64_t counter = 1;	2506	uint64_t counter = 1;
1873	write (evfd, &counter, sizeof (uint64_t));	2507	write (evpipe [1], &counter, sizeof (uint64_t));
1874	}	2508	}
1875	else	2509	else
1876	#endif	2510	#endif
1877	{	2511	{
1878	#ifdef _WIN32	2512	#ifdef _WIN32
1879	WSABUF buf;	2513	WSABUF buf;
1880	DWORD sent;	2514	DWORD sent;
1881	buf.buf = &buf;	2515	buf.buf = (char *)&buf;
1882	buf.len = 1;	2516	buf.len = 1;
1883	WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);	2517	WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
1884	#else	2518	#else
1885	write (evpipe [1], &(evpipe [1]), 1);	2519	write (evpipe [1], &(evpipe [1]), 1);
1886	#endif	2520	#endif
…		…
1898	int i;	2532	int i;
1899		2533
1900	if (revents & EV_READ)	2534	if (revents & EV_READ)
1901	{	2535	{
1902	#if EV_USE_EVENTFD	2536	#if EV_USE_EVENTFD
1903	if (evfd >= 0)	2537	if (evpipe [0] < 0)
1904	{	2538	{
1905	uint64_t counter;	2539	uint64_t counter;
1906	read (evfd, &counter, sizeof (uint64_t));	2540	read (evpipe [1], &counter, sizeof (uint64_t));
1907	}	2541	}
1908	else	2542	else
1909	#endif	2543	#endif
1910	{	2544	{
1911	char dummy[4];	2545	char dummy[4];
1912	#ifdef _WIN32	2546	#ifdef _WIN32
1913	WSABUF buf;	2547	WSABUF buf;
1914	DWORD recvd;	2548	DWORD recvd;
		2549	DWORD flags = 0;
1915	buf.buf = dummy;	2550	buf.buf = dummy;
1916	buf.len = sizeof (dummy);	2551	buf.len = sizeof (dummy);
1917	WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, 0, 0, 0);	2552	WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, &flags, 0, 0);
1918	#else	2553	#else
1919	read (evpipe [0], &dummy, sizeof (dummy));	2554	read (evpipe [0], &dummy, sizeof (dummy));
1920	#endif	2555	#endif
1921	}	2556	}
1922	}	2557	}
…		…
1928	#if EV_SIGNAL_ENABLE	2563	#if EV_SIGNAL_ENABLE
1929	if (sig_pending)	2564	if (sig_pending)
1930	{	2565	{
1931	sig_pending = 0;	2566	sig_pending = 0;
1932		2567
1933	ECB_MEMORY_FENCE_RELEASE;	2568	ECB_MEMORY_FENCE;
1934		2569
1935	for (i = EV_NSIG - 1; i--; )	2570	for (i = EV_NSIG - 1; i--; )
1936	if (expect_false (signals [i].pending))	2571	if (expect_false (signals [i].pending))
1937	ev_feed_signal_event (EV_A_ i + 1);	2572	ev_feed_signal_event (EV_A_ i + 1);
1938	}	2573	}
…		…
1941	#if EV_ASYNC_ENABLE	2576	#if EV_ASYNC_ENABLE
1942	if (async_pending)	2577	if (async_pending)
1943	{	2578	{
1944	async_pending = 0;	2579	async_pending = 0;
1945		2580
1946	ECB_MEMORY_FENCE_RELEASE;	2581	ECB_MEMORY_FENCE;
1947		2582
1948	for (i = asynccnt; i--; )	2583	for (i = asynccnt; i--; )
1949	if (asyncs [i]->sent)	2584	if (asyncs [i]->sent)
1950	{	2585	{
1951	asyncs [i]->sent = 0;	2586	asyncs [i]->sent = 0;
		2587	ECB_MEMORY_FENCE_RELEASE;
1952	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);	2588	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
1953	}	2589	}
1954	}	2590	}
1955	#endif	2591	#endif
1956	}	2592	}
1957		2593
1958	/*****************************************************************************/	2594	/*****************************************************************************/
1959		2595
1960	void	2596	void
1961	ev_feed_signal (int signum) EV_THROW	2597	ev_feed_signal (int signum) EV_NOEXCEPT
1962	{	2598	{
1963	#if EV_MULTIPLICITY	2599	#if EV_MULTIPLICITY
		2600	EV_P;
		2601	ECB_MEMORY_FENCE_ACQUIRE;
1964	EV_P = signals [signum - 1].loop;	2602	EV_A = signals [signum - 1].loop;
1965		2603
1966	if (!EV_A)	2604	if (!EV_A)
1967	return;	2605	return;
1968	#endif	2606	#endif
1969		2607
1970	if (!ev_active (&pipe_w))
1971	return;
1972
1973	signals [signum - 1].pending = 1;	2608	signals [signum - 1].pending = 1;
1974	evpipe_write (EV_A_ &sig_pending);	2609	evpipe_write (EV_A_ &sig_pending);
1975	}	2610	}
1976		2611
1977	static void	2612	static void
…		…
1982	#endif	2617	#endif
1983		2618
1984	ev_feed_signal (signum);	2619	ev_feed_signal (signum);
1985	}	2620	}
1986		2621
1987	void noinline	2622	noinline
		2623	void
1988	ev_feed_signal_event (EV_P_ int signum) EV_THROW	2624	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
1989	{	2625	{
1990	WL w;	2626	WL w;
1991		2627
1992	if (expect_false (signum <= 0 || signum > EV_NSIG))	2628	if (expect_false (signum <= 0 || signum >= EV_NSIG))
1993	return;	2629	return;
1994		2630
1995	--signum;	2631	--signum;
1996		2632
1997	#if EV_MULTIPLICITY	2633	#if EV_MULTIPLICITY
…		…
2001	if (expect_false (signals [signum].loop != EV_A))	2637	if (expect_false (signals [signum].loop != EV_A))
2002	return;	2638	return;
2003	#endif	2639	#endif
2004		2640
2005	signals [signum].pending = 0;	2641	signals [signum].pending = 0;
		2642	ECB_MEMORY_FENCE_RELEASE;
2006		2643
2007	for (w = signals [signum].head; w; w = w->next)	2644	for (w = signals [signum].head; w; w = w->next)
2008	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);	2645	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
2009	}	2646	}
2010		2647
…		…
2101	# include "ev_kqueue.c"	2738	# include "ev_kqueue.c"
2102	#endif	2739	#endif
2103	#if EV_USE_EPOLL	2740	#if EV_USE_EPOLL
2104	# include "ev_epoll.c"	2741	# include "ev_epoll.c"
2105	#endif	2742	#endif
		2743	#if EV_USE_LINUXAIO
		2744	# include "ev_linuxaio.c"
		2745	#endif
2106	#if EV_USE_POLL	2746	#if EV_USE_POLL
2107	# include "ev_poll.c"	2747	# include "ev_poll.c"
2108	#endif	2748	#endif
2109	#if EV_USE_SELECT	2749	#if EV_USE_SELECT
2110	# include "ev_select.c"	2750	# include "ev_select.c"
2111	#endif	2751	#endif
2112		2752
2113	int ecb_cold	2753	ecb_cold int
2114	ev_version_major (void) EV_THROW	2754	ev_version_major (void) EV_NOEXCEPT
2115	{	2755	{
2116	return EV_VERSION_MAJOR;	2756	return EV_VERSION_MAJOR;
2117	}	2757	}
2118		2758
2119	int ecb_cold	2759	ecb_cold int
2120	ev_version_minor (void) EV_THROW	2760	ev_version_minor (void) EV_NOEXCEPT
2121	{	2761	{
2122	return EV_VERSION_MINOR;	2762	return EV_VERSION_MINOR;
2123	}	2763	}
2124		2764
2125	/* return true if we are running with elevated privileges and should ignore env variables */	2765	/* return true if we are running with elevated privileges and should ignore env variables */
2126	int inline_size ecb_cold	2766	inline_size ecb_cold int
2127	enable_secure (void)	2767	enable_secure (void)
2128	{	2768	{
2129	#ifdef _WIN32	2769	#ifdef _WIN32
2130	return 0;	2770	return 0;
2131	#else	2771	#else
2132	return getuid () != geteuid ()	2772	return getuid () != geteuid ()
2133	|| getgid () != getegid ();	2773	|| getgid () != getegid ();
2134	#endif	2774	#endif
2135	}	2775	}
2136		2776
2137	unsigned int ecb_cold	2777	ecb_cold
		2778	unsigned int
2138	ev_supported_backends (void) EV_THROW	2779	ev_supported_backends (void) EV_NOEXCEPT
2139	{	2780	{
2140	unsigned int flags = 0;	2781	unsigned int flags = 0;
2141		2782
2142	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	2783	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2143	if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;	2784	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2144	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	2785	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
		2786	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;
2145	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	2787	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2146	if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;	2788	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
2147		2789
2148	return flags;	2790	return flags;
2149	}	2791	}
2150		2792
2151	unsigned int ecb_cold	2793	ecb_cold
		2794	unsigned int
2152	ev_recommended_backends (void) EV_THROW	2795	ev_recommended_backends (void) EV_NOEXCEPT
2153	{	2796	{
2154	unsigned int flags = ev_supported_backends ();	2797	unsigned int flags = ev_supported_backends ();
2155		2798
2156	#ifndef __NetBSD__	2799	#ifndef __NetBSD__
2157	/* kqueue is borked on everything but netbsd apparently */	2800	/* kqueue is borked on everything but netbsd apparently */
…		…
2165	#endif	2808	#endif
2166	#ifdef __FreeBSD__	2809	#ifdef __FreeBSD__
2167	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */	2810	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
2168	#endif	2811	#endif
2169		2812
		2813	/* TODO: linuxaio is very experimental */
		2814	#if !EV_RECOMMEND_LINUXAIO
		2815	flags &= ~EVBACKEND_LINUXAIO;
		2816	#endif
		2817
2170	return flags;	2818	return flags;
2171	}	2819	}
2172		2820
2173	unsigned int ecb_cold	2821	ecb_cold
		2822	unsigned int
2174	ev_embeddable_backends (void) EV_THROW	2823	ev_embeddable_backends (void) EV_NOEXCEPT
2175	{	2824	{
2176	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	2825	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2177		2826
2178	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	2827	/* 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 */	2828	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
…		…
2181		2830
2182	return flags;	2831	return flags;
2183	}	2832	}
2184		2833
2185	unsigned int	2834	unsigned int
2186	ev_backend (EV_P) EV_THROW	2835	ev_backend (EV_P) EV_NOEXCEPT
2187	{	2836	{
2188	return backend;	2837	return backend;
2189	}	2838	}
2190		2839
2191	#if EV_FEATURE_API	2840	#if EV_FEATURE_API
2192	unsigned int	2841	unsigned int
2193	ev_iteration (EV_P) EV_THROW	2842	ev_iteration (EV_P) EV_NOEXCEPT
2194	{	2843	{
2195	return loop_count;	2844	return loop_count;
2196	}	2845	}
2197		2846
2198	unsigned int	2847	unsigned int
2199	ev_depth (EV_P) EV_THROW	2848	ev_depth (EV_P) EV_NOEXCEPT
2200	{	2849	{
2201	return loop_depth;	2850	return loop_depth;
2202	}	2851	}
2203		2852
2204	void	2853	void
2205	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	2854	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2206	{	2855	{
2207	io_blocktime = interval;	2856	io_blocktime = interval;
2208	}	2857	}
2209		2858
2210	void	2859	void
2211	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	2860	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2212	{	2861	{
2213	timeout_blocktime = interval;	2862	timeout_blocktime = interval;
2214	}	2863	}
2215		2864
2216	void	2865	void
2217	ev_set_userdata (EV_P_ void *data) EV_THROW	2866	ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT
2218	{	2867	{
2219	userdata = data;	2868	userdata = data;
2220	}	2869	}
2221		2870
2222	void *	2871	void *
2223	ev_userdata (EV_P) EV_THROW	2872	ev_userdata (EV_P) EV_NOEXCEPT
2224	{	2873	{
2225	return userdata;	2874	return userdata;
2226	}	2875	}
2227		2876
2228	void	2877	void
2229	ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW	2878	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT
2230	{	2879	{
2231	invoke_cb = invoke_pending_cb;	2880	invoke_cb = invoke_pending_cb;
2232	}	2881	}
2233		2882
2234	void	2883	void
2235	ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW	2884	ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT
2236	{	2885	{
2237	release_cb = release;	2886	release_cb = release;
2238	acquire_cb = acquire;	2887	acquire_cb = acquire;
2239	}	2888	}
2240	#endif	2889	#endif
2241		2890
2242	/* initialise a loop structure, must be zero-initialised */	2891	/* initialise a loop structure, must be zero-initialised */
2243	static void noinline ecb_cold	2892	noinline ecb_cold
		2893	static void
2244	loop_init (EV_P_ unsigned int flags) EV_THROW	2894	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2245	{	2895	{
2246	if (!backend)	2896	if (!backend)
2247	{	2897	{
2248	origflags = flags;	2898	origflags = flags;
2249		2899
…		…
2294	#if EV_ASYNC_ENABLE	2944	#if EV_ASYNC_ENABLE
2295	async_pending = 0;	2945	async_pending = 0;
2296	#endif	2946	#endif
2297	pipe_write_skipped = 0;	2947	pipe_write_skipped = 0;
2298	pipe_write_wanted = 0;	2948	pipe_write_wanted = 0;
		2949	evpipe [0] = -1;
		2950	evpipe [1] = -1;
2299	#if EV_USE_INOTIFY	2951	#if EV_USE_INOTIFY
2300	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	2952	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2301	#endif	2953	#endif
2302	#if EV_USE_SIGNALFD	2954	#if EV_USE_SIGNALFD
2303	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	2955	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
…		…
2305		2957
2306	if (!(flags & EVBACKEND_MASK))	2958	if (!(flags & EVBACKEND_MASK))
2307	flags |= ev_recommended_backends ();	2959	flags |= ev_recommended_backends ();
2308		2960
2309	#if EV_USE_IOCP	2961	#if EV_USE_IOCP
2310	if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);	2962	if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);
2311	#endif	2963	#endif
2312	#if EV_USE_PORT	2964	#if EV_USE_PORT
2313	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	2965	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2314	#endif	2966	#endif
2315	#if EV_USE_KQUEUE	2967	#if EV_USE_KQUEUE
2316	if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);	2968	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
		2969	#endif
		2970	#if EV_USE_LINUXAIO
		2971	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2317	#endif	2972	#endif
2318	#if EV_USE_EPOLL	2973	#if EV_USE_EPOLL
2319	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);	2974	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
2320	#endif	2975	#endif
2321	#if EV_USE_POLL	2976	#if EV_USE_POLL
2322	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);	2977	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
2323	#endif	2978	#endif
2324	#if EV_USE_SELECT	2979	#if EV_USE_SELECT
2325	if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);	2980	if (!backend && (flags & EVBACKEND_SELECT )) backend = select_init (EV_A_ flags);
2326	#endif	2981	#endif
2327		2982
2328	ev_prepare_init (&pending_w, pendingcb);	2983	ev_prepare_init (&pending_w, pendingcb);
2329		2984
2330	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2985	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
…		…
2333	#endif	2988	#endif
2334	}	2989	}
2335	}	2990	}
2336		2991
2337	/* free up a loop structure */	2992	/* free up a loop structure */
2338	void ecb_cold	2993	ecb_cold
		2994	void
2339	ev_loop_destroy (EV_P)	2995	ev_loop_destroy (EV_P)
2340	{	2996	{
2341	int i;	2997	int i;
2342		2998
2343	#if EV_MULTIPLICITY	2999	#if EV_MULTIPLICITY
…		…
2354	EV_INVOKE_PENDING;	3010	EV_INVOKE_PENDING;
2355	}	3011	}
2356	#endif	3012	#endif
2357		3013
2358	#if EV_CHILD_ENABLE	3014	#if EV_CHILD_ENABLE
2359	if (ev_is_active (&childev))	3015	if (ev_is_default_loop (EV_A) && ev_is_active (&childev))
2360	{	3016	{
2361	ev_ref (EV_A); /* child watcher */	3017	ev_ref (EV_A); /* child watcher */
2362	ev_signal_stop (EV_A_ &childev);	3018	ev_signal_stop (EV_A_ &childev);
2363	}	3019	}
2364	#endif	3020	#endif
…		…
2366	if (ev_is_active (&pipe_w))	3022	if (ev_is_active (&pipe_w))
2367	{	3023	{
2368	/*ev_ref (EV_A);*/	3024	/*ev_ref (EV_A);*/
2369	/*ev_io_stop (EV_A_ &pipe_w);*/	3025	/*ev_io_stop (EV_A_ &pipe_w);*/
2370		3026
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]);	3027	if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
2379	EV_WIN32_CLOSE_FD (evpipe [1]);	3028	if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
2380	}
2381	}	3029	}
2382		3030
2383	#if EV_USE_SIGNALFD	3031	#if EV_USE_SIGNALFD
2384	if (ev_is_active (&sigfd_w))	3032	if (ev_is_active (&sigfd_w))
2385	close (sigfd);	3033	close (sigfd);
…		…
2392		3040
2393	if (backend_fd >= 0)	3041	if (backend_fd >= 0)
2394	close (backend_fd);	3042	close (backend_fd);
2395		3043
2396	#if EV_USE_IOCP	3044	#if EV_USE_IOCP
2397	if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);	3045	if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);
2398	#endif	3046	#endif
2399	#if EV_USE_PORT	3047	#if EV_USE_PORT
2400	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3048	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
2401	#endif	3049	#endif
2402	#if EV_USE_KQUEUE	3050	#if EV_USE_KQUEUE
2403	if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);	3051	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
		3052	#endif
		3053	#if EV_USE_LINUXAIO
		3054	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
2404	#endif	3055	#endif
2405	#if EV_USE_EPOLL	3056	#if EV_USE_EPOLL
2406	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);	3057	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
2407	#endif	3058	#endif
2408	#if EV_USE_POLL	3059	#if EV_USE_POLL
2409	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);	3060	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
2410	#endif	3061	#endif
2411	#if EV_USE_SELECT	3062	#if EV_USE_SELECT
2412	if (backend == EVBACKEND_SELECT) select_destroy (EV_A);	3063	if (backend == EVBACKEND_SELECT ) select_destroy (EV_A);
2413	#endif	3064	#endif
2414		3065
2415	for (i = NUMPRI; i--; )	3066	for (i = NUMPRI; i--; )
2416	{	3067	{
2417	array_free (pending, [i]);	3068	array_free (pending, [i]);
…		…
2459		3110
2460	inline_size void	3111	inline_size void
2461	loop_fork (EV_P)	3112	loop_fork (EV_P)
2462	{	3113	{
2463	#if EV_USE_PORT	3114	#if EV_USE_PORT
2464	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3115	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
2465	#endif	3116	#endif
2466	#if EV_USE_KQUEUE	3117	#if EV_USE_KQUEUE
2467	if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);	3118	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
		3119	#endif
		3120	#if EV_USE_LINUXAIO
		3121	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
2468	#endif	3122	#endif
2469	#if EV_USE_EPOLL	3123	#if EV_USE_EPOLL
2470	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3124	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
2471	#endif	3125	#endif
2472	#if EV_USE_INOTIFY	3126	#if EV_USE_INOTIFY
2473	infy_fork (EV_A);	3127	infy_fork (EV_A);
2474	#endif	3128	#endif
2475		3129
		3130	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2476	if (ev_is_active (&pipe_w))	3131	if (ev_is_active (&pipe_w) && postfork != 2)
2477	{	3132	{
2478	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3133	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2479		3134
2480	ev_ref (EV_A);	3135	ev_ref (EV_A);
2481	ev_io_stop (EV_A_ &pipe_w);	3136	ev_io_stop (EV_A_ &pipe_w);
2482		3137
2483	#if EV_USE_EVENTFD
2484	if (evfd >= 0)
2485	close (evfd);
2486	#endif
2487
2488	if (evpipe [0] >= 0)	3138	if (evpipe [0] >= 0)
2489	{
2490	EV_WIN32_CLOSE_FD (evpipe [0]);	3139	EV_WIN32_CLOSE_FD (evpipe [0]);
2491	EV_WIN32_CLOSE_FD (evpipe [1]);
2492	}
2493		3140
2494	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2495	evpipe_init (EV_A);	3141	evpipe_init (EV_A);
2496	/* now iterate over everything, in case we missed something */	3142	/* iterate over everything, in case we missed something before */
2497	pipecb (EV_A_ &pipe_w, EV_READ);	3143	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2498	#endif
2499	}	3144	}
		3145	#endif
2500		3146
2501	postfork = 0;	3147	postfork = 0;
2502	}	3148	}
2503		3149
2504	#if EV_MULTIPLICITY	3150	#if EV_MULTIPLICITY
2505		3151
		3152	ecb_cold
2506	struct ev_loop * ecb_cold	3153	struct ev_loop *
2507	ev_loop_new (unsigned int flags) EV_THROW	3154	ev_loop_new (unsigned int flags) EV_NOEXCEPT
2508	{	3155	{
2509	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));	3156	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2510		3157
2511	memset (EV_A, 0, sizeof (struct ev_loop));	3158	memset (EV_A, 0, sizeof (struct ev_loop));
2512	loop_init (EV_A_ flags);	3159	loop_init (EV_A_ flags);
…		…
2519	}	3166	}
2520		3167
2521	#endif /* multiplicity */	3168	#endif /* multiplicity */
2522		3169
2523	#if EV_VERIFY	3170	#if EV_VERIFY
2524	static void noinline ecb_cold	3171	noinline ecb_cold
		3172	static void
2525	verify_watcher (EV_P_ W w)	3173	verify_watcher (EV_P_ W w)
2526	{	3174	{
2527	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3175	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
2528		3176
2529	if (w->pending)	3177	if (w->pending)
2530	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3178	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
2531	}	3179	}
2532		3180
2533	static void noinline ecb_cold	3181	noinline ecb_cold
		3182	static void
2534	verify_heap (EV_P_ ANHE *heap, int N)	3183	verify_heap (EV_P_ ANHE *heap, int N)
2535	{	3184	{
2536	int i;	3185	int i;
2537		3186
2538	for (i = HEAP0; i < N + HEAP0; ++i)	3187	for (i = HEAP0; i < N + HEAP0; ++i)
…		…
2543		3192
2544	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3193	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
2545	}	3194	}
2546	}	3195	}
2547		3196
2548	static void noinline ecb_cold	3197	noinline ecb_cold
		3198	static void
2549	array_verify (EV_P_ W *ws, int cnt)	3199	array_verify (EV_P_ W *ws, int cnt)
2550	{	3200	{
2551	while (cnt--)	3201	while (cnt--)
2552	{	3202	{
2553	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));	3203	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
…		…
2556	}	3206	}
2557	#endif	3207	#endif
2558		3208
2559	#if EV_FEATURE_API	3209	#if EV_FEATURE_API
2560	void ecb_cold	3210	void ecb_cold
2561	ev_verify (EV_P) EV_THROW	3211	ev_verify (EV_P) EV_NOEXCEPT
2562	{	3212	{
2563	#if EV_VERIFY	3213	#if EV_VERIFY
2564	int i;	3214	int i;
2565	WL w, w2;	3215	WL w, w2;
2566		3216
…		…
2642	#endif	3292	#endif
2643	}	3293	}
2644	#endif	3294	#endif
2645		3295
2646	#if EV_MULTIPLICITY	3296	#if EV_MULTIPLICITY
		3297	ecb_cold
2647	struct ev_loop * ecb_cold	3298	struct ev_loop *
2648	#else	3299	#else
2649	int	3300	int
2650	#endif	3301	#endif
2651	ev_default_loop (unsigned int flags) EV_THROW	3302	ev_default_loop (unsigned int flags) EV_NOEXCEPT
2652	{	3303	{
2653	if (!ev_default_loop_ptr)	3304	if (!ev_default_loop_ptr)
2654	{	3305	{
2655	#if EV_MULTIPLICITY	3306	#if EV_MULTIPLICITY
2656	EV_P = ev_default_loop_ptr = &default_loop_struct;	3307	EV_P = ev_default_loop_ptr = &default_loop_struct;
…		…
2675		3326
2676	return ev_default_loop_ptr;	3327	return ev_default_loop_ptr;
2677	}	3328	}
2678		3329
2679	void	3330	void
2680	ev_loop_fork (EV_P) EV_THROW	3331	ev_loop_fork (EV_P) EV_NOEXCEPT
2681	{	3332	{
2682	postfork = 1; /* must be in line with ev_default_fork */	3333	postfork = 1;
2683	}	3334	}
2684		3335
2685	/*****************************************************************************/	3336	/*****************************************************************************/
2686		3337
2687	void	3338	void
…		…
2689	{	3340	{
2690	EV_CB_INVOKE ((W)w, revents);	3341	EV_CB_INVOKE ((W)w, revents);
2691	}	3342	}
2692		3343
2693	unsigned int	3344	unsigned int
2694	ev_pending_count (EV_P) EV_THROW	3345	ev_pending_count (EV_P) EV_NOEXCEPT
2695	{	3346	{
2696	int pri;	3347	int pri;
2697	unsigned int count = 0;	3348	unsigned int count = 0;
2698		3349
2699	for (pri = NUMPRI; pri--; )	3350	for (pri = NUMPRI; pri--; )
2700	count += pendingcnt [pri];	3351	count += pendingcnt [pri];
2701		3352
2702	return count;	3353	return count;
2703	}	3354	}
2704		3355
2705	void noinline	3356	noinline
		3357	void
2706	ev_invoke_pending (EV_P)	3358	ev_invoke_pending (EV_P)
2707	{	3359	{
2708	for (pendingpri = NUMPRI; pendingpri--; ) /* pendingpri is modified during the loop */	3360	pendingpri = NUMPRI;
		3361
		3362	do
		3363	{
		3364	--pendingpri;
		3365
		3366	/* pendingpri possibly gets modified in the inner loop */
2709	while (pendingcnt [pendingpri])	3367	while (pendingcnt [pendingpri])
2710	{	3368	{
2711	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];	3369	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2712		3370
2713	p->w->pending = 0;	3371	p->w->pending = 0;
2714	EV_CB_INVOKE (p->w, p->events);	3372	EV_CB_INVOKE (p->w, p->events);
2715	EV_FREQUENT_CHECK;	3373	EV_FREQUENT_CHECK;
2716	}	3374	}
		3375	}
		3376	while (pendingpri);
2717	}	3377	}
2718		3378
2719	#if EV_IDLE_ENABLE	3379	#if EV_IDLE_ENABLE
2720	/* make idle watchers pending. this handles the "call-idle */	3380	/* make idle watchers pending. this handles the "call-idle */
2721	/* only when higher priorities are idle" logic */	3381	/* only when higher priorities are idle" logic */
…		…
2779	}	3439	}
2780	}	3440	}
2781		3441
2782	#if EV_PERIODIC_ENABLE	3442	#if EV_PERIODIC_ENABLE
2783		3443
2784	static void noinline	3444	noinline
		3445	static void
2785	periodic_recalc (EV_P_ ev_periodic *w)	3446	periodic_recalc (EV_P_ ev_periodic *w)
2786	{	3447	{
2787	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3448	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);	3449	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
2789		3450
…		…
2811	{	3472	{
2812	EV_FREQUENT_CHECK;	3473	EV_FREQUENT_CHECK;
2813		3474
2814	while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)	3475	while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
2815	{	3476	{
2816	int feed_count = 0;
2817
2818	do	3477	do
2819	{	3478	{
2820	ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);	3479	ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
2821		3480
2822	/*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/	3481	/*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/
…		…
2849	}	3508	}
2850	}	3509	}
2851		3510
2852	/* simply recalculate all periodics */	3511	/* simply recalculate all periodics */
2853	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3512	/* TODO: maybe ensure that at least one event happens when jumping forward? */
2854	static void noinline ecb_cold	3513	noinline ecb_cold
		3514	static void
2855	periodics_reschedule (EV_P)	3515	periodics_reschedule (EV_P)
2856	{	3516	{
2857	int i;	3517	int i;
2858		3518
2859	/* adjust periodics after time jump */	3519	/* adjust periodics after time jump */
…		…
2872	reheap (periodics, periodiccnt);	3532	reheap (periodics, periodiccnt);
2873	}	3533	}
2874	#endif	3534	#endif
2875		3535
2876	/* adjust all timers by a given offset */	3536	/* adjust all timers by a given offset */
2877	static void noinline ecb_cold	3537	noinline ecb_cold
		3538	static void
2878	timers_reschedule (EV_P_ ev_tstamp adjust)	3539	timers_reschedule (EV_P_ ev_tstamp adjust)
2879	{	3540	{
2880	int i;	3541	int i;
2881		3542
2882	for (i = 0; i < timercnt; ++i)	3543	for (i = 0; i < timercnt; ++i)
…		…
3081	backend_poll (EV_A_ waittime);	3742	backend_poll (EV_A_ waittime);
3082	assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */	3743	assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
3083		3744
3084	pipe_write_wanted = 0; /* just an optimisation, no fence needed */	3745	pipe_write_wanted = 0; /* just an optimisation, no fence needed */
3085		3746
		3747	ECB_MEMORY_FENCE_ACQUIRE;
3086	if (pipe_write_skipped)	3748	if (pipe_write_skipped)
3087	{	3749	{
3088	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	3750	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);	3751	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3090	}	3752	}
3091		3753
3092
3093	/* update ev_rt_now, do magic */	3754	/* update ev_rt_now, do magic */
3094	time_update (EV_A_ waittime + sleeptime);	3755	time_update (EV_A_ waittime + sleeptime);
3095	}	3756	}
3096		3757
3097	/* queue pending timers and reschedule them */	3758	/* queue pending timers and reschedule them */
…		…
3128		3789
3129	return activecnt;	3790	return activecnt;
3130	}	3791	}
3131		3792
3132	void	3793	void
3133	ev_break (EV_P_ int how) EV_THROW	3794	ev_break (EV_P_ int how) EV_NOEXCEPT
3134	{	3795	{
3135	loop_done = how;	3796	loop_done = how;
3136	}	3797	}
3137		3798
3138	void	3799	void
3139	ev_ref (EV_P) EV_THROW	3800	ev_ref (EV_P) EV_NOEXCEPT
3140	{	3801	{
3141	++activecnt;	3802	++activecnt;
3142	}	3803	}
3143		3804
3144	void	3805	void
3145	ev_unref (EV_P) EV_THROW	3806	ev_unref (EV_P) EV_NOEXCEPT
3146	{	3807	{
3147	--activecnt;	3808	--activecnt;
3148	}	3809	}
3149		3810
3150	void	3811	void
3151	ev_now_update (EV_P) EV_THROW	3812	ev_now_update (EV_P) EV_NOEXCEPT
3152	{	3813	{
3153	time_update (EV_A_ 1e100);	3814	time_update (EV_A_ 1e100);
3154	}	3815	}
3155		3816
3156	void	3817	void
3157	ev_suspend (EV_P) EV_THROW	3818	ev_suspend (EV_P) EV_NOEXCEPT
3158	{	3819	{
3159	ev_now_update (EV_A);	3820	ev_now_update (EV_A);
3160	}	3821	}
3161		3822
3162	void	3823	void
3163	ev_resume (EV_P) EV_THROW	3824	ev_resume (EV_P) EV_NOEXCEPT
3164	{	3825	{
3165	ev_tstamp mn_prev = mn_now;	3826	ev_tstamp mn_prev = mn_now;
3166		3827
3167	ev_now_update (EV_A);	3828	ev_now_update (EV_A);
3168	timers_reschedule (EV_A_ mn_now - mn_prev);	3829	timers_reschedule (EV_A_ mn_now - mn_prev);
…		…
3207	w->pending = 0;	3868	w->pending = 0;
3208	}	3869	}
3209	}	3870	}
3210		3871
3211	int	3872	int
3212	ev_clear_pending (EV_P_ void *w) EV_THROW	3873	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3213	{	3874	{
3214	W w_ = (W)w;	3875	W w_ = (W)w;
3215	int pending = w_->pending;	3876	int pending = w_->pending;
3216		3877
3217	if (expect_true (pending))	3878	if (expect_true (pending))
…		…
3249	w->active = 0;	3910	w->active = 0;
3250	}	3911	}
3251		3912
3252	/*****************************************************************************/	3913	/*****************************************************************************/
3253		3914
3254	void noinline	3915	noinline
		3916	void
3255	ev_io_start (EV_P_ ev_io *w) EV_THROW	3917	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3256	{	3918	{
3257	int fd = w->fd;	3919	int fd = w->fd;
3258		3920
3259	if (expect_false (ev_is_active (w)))	3921	if (expect_false (ev_is_active (w)))
3260	return;	3922	return;
3261		3923
3262	assert (("libev: ev_io_start called with negative fd", fd >= 0));	3924	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))));	3925	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3264		3926
		3927	#if EV_VERIFY >= 2
		3928	assert (("libev: ev_io_start called on watcher with invalid fd", fd_valid (fd)));
		3929	#endif
3265	EV_FREQUENT_CHECK;	3930	EV_FREQUENT_CHECK;
3266		3931
3267	ev_start (EV_A_ (W)w, 1);	3932	ev_start (EV_A_ (W)w, 1);
3268	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	3933	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);
3269	wlist_add (&anfds[fd].head, (WL)w);	3934	wlist_add (&anfds[fd].head, (WL)w);
3270		3935
3271	/* common bug, apparently */	3936	/* common bug, apparently */
3272	assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));	3937	assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3273		3938
…		…
3275	w->events &= ~EV__IOFDSET;	3940	w->events &= ~EV__IOFDSET;
3276		3941
3277	EV_FREQUENT_CHECK;	3942	EV_FREQUENT_CHECK;
3278	}	3943	}
3279		3944
3280	void noinline	3945	noinline
		3946	void
3281	ev_io_stop (EV_P_ ev_io *w) EV_THROW	3947	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3282	{	3948	{
3283	clear_pending (EV_A_ (W)w);	3949	clear_pending (EV_A_ (W)w);
3284	if (expect_false (!ev_is_active (w)))	3950	if (expect_false (!ev_is_active (w)))
3285	return;	3951	return;
3286		3952
3287	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));	3953	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3288		3954
		3955	#if EV_VERIFY >= 2
		3956	assert (("libev: ev_io_stop called on watcher with invalid fd", fd_valid (w->fd)));
		3957	#endif
3289	EV_FREQUENT_CHECK;	3958	EV_FREQUENT_CHECK;
3290		3959
3291	wlist_del (&anfds[w->fd].head, (WL)w);	3960	wlist_del (&anfds[w->fd].head, (WL)w);
3292	ev_stop (EV_A_ (W)w);	3961	ev_stop (EV_A_ (W)w);
3293		3962
3294	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	3963	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3295		3964
3296	EV_FREQUENT_CHECK;	3965	EV_FREQUENT_CHECK;
3297	}	3966	}
3298		3967
3299	void noinline	3968	noinline
		3969	void
3300	ev_timer_start (EV_P_ ev_timer *w) EV_THROW	3970	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3301	{	3971	{
3302	if (expect_false (ev_is_active (w)))	3972	if (expect_false (ev_is_active (w)))
3303	return;	3973	return;
3304		3974
3305	ev_at (w) += mn_now;	3975	ev_at (w) += mn_now;
…		…
3308		3978
3309	EV_FREQUENT_CHECK;	3979	EV_FREQUENT_CHECK;
3310		3980
3311	++timercnt;	3981	++timercnt;
3312	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);	3982	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
3313	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);	3983	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, array_needsize_noinit);
3314	ANHE_w (timers [ev_active (w)]) = (WT)w;	3984	ANHE_w (timers [ev_active (w)]) = (WT)w;
3315	ANHE_at_cache (timers [ev_active (w)]);	3985	ANHE_at_cache (timers [ev_active (w)]);
3316	upheap (timers, ev_active (w));	3986	upheap (timers, ev_active (w));
3317		3987
3318	EV_FREQUENT_CHECK;	3988	EV_FREQUENT_CHECK;
3319		3989
3320	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	3990	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3321	}	3991	}
3322		3992
3323	void noinline	3993	noinline
		3994	void
3324	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW	3995	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3325	{	3996	{
3326	clear_pending (EV_A_ (W)w);	3997	clear_pending (EV_A_ (W)w);
3327	if (expect_false (!ev_is_active (w)))	3998	if (expect_false (!ev_is_active (w)))
3328	return;	3999	return;
3329		4000
…		…
3348	ev_stop (EV_A_ (W)w);	4019	ev_stop (EV_A_ (W)w);
3349		4020
3350	EV_FREQUENT_CHECK;	4021	EV_FREQUENT_CHECK;
3351	}	4022	}
3352		4023
3353	void noinline	4024	noinline
		4025	void
3354	ev_timer_again (EV_P_ ev_timer *w) EV_THROW	4026	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
3355	{	4027	{
3356	EV_FREQUENT_CHECK;	4028	EV_FREQUENT_CHECK;
3357		4029
3358	clear_pending (EV_A_ (W)w);	4030	clear_pending (EV_A_ (W)w);
3359		4031
…		…
3376		4048
3377	EV_FREQUENT_CHECK;	4049	EV_FREQUENT_CHECK;
3378	}	4050	}
3379		4051
3380	ev_tstamp	4052	ev_tstamp
3381	ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW	4053	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
3382	{	4054	{
3383	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4055	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3384	}	4056	}
3385		4057
3386	#if EV_PERIODIC_ENABLE	4058	#if EV_PERIODIC_ENABLE
3387	void noinline	4059	noinline
		4060	void
3388	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW	4061	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
3389	{	4062	{
3390	if (expect_false (ev_is_active (w)))	4063	if (expect_false (ev_is_active (w)))
3391	return;	4064	return;
3392		4065
3393	if (w->reschedule_cb)	4066	if (w->reschedule_cb)
…		…
3402		4075
3403	EV_FREQUENT_CHECK;	4076	EV_FREQUENT_CHECK;
3404		4077
3405	++periodiccnt;	4078	++periodiccnt;
3406	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);	4079	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
3407	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);	4080	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, array_needsize_noinit);
3408	ANHE_w (periodics [ev_active (w)]) = (WT)w;	4081	ANHE_w (periodics [ev_active (w)]) = (WT)w;
3409	ANHE_at_cache (periodics [ev_active (w)]);	4082	ANHE_at_cache (periodics [ev_active (w)]);
3410	upheap (periodics, ev_active (w));	4083	upheap (periodics, ev_active (w));
3411		4084
3412	EV_FREQUENT_CHECK;	4085	EV_FREQUENT_CHECK;
3413		4086
3414	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4087	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3415	}	4088	}
3416		4089
3417	void noinline	4090	noinline
		4091	void
3418	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW	4092	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
3419	{	4093	{
3420	clear_pending (EV_A_ (W)w);	4094	clear_pending (EV_A_ (W)w);
3421	if (expect_false (!ev_is_active (w)))	4095	if (expect_false (!ev_is_active (w)))
3422	return;	4096	return;
3423		4097
…		…
3440	ev_stop (EV_A_ (W)w);	4114	ev_stop (EV_A_ (W)w);
3441		4115
3442	EV_FREQUENT_CHECK;	4116	EV_FREQUENT_CHECK;
3443	}	4117	}
3444		4118
3445	void noinline	4119	noinline
		4120	void
3446	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW	4121	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
3447	{	4122	{
3448	/* TODO: use adjustheap and recalculation */	4123	/* TODO: use adjustheap and recalculation */
3449	ev_periodic_stop (EV_A_ w);	4124	ev_periodic_stop (EV_A_ w);
3450	ev_periodic_start (EV_A_ w);	4125	ev_periodic_start (EV_A_ w);
3451	}	4126	}
…		…
3455	# define SA_RESTART 0	4130	# define SA_RESTART 0
3456	#endif	4131	#endif
3457		4132
3458	#if EV_SIGNAL_ENABLE	4133	#if EV_SIGNAL_ENABLE
3459		4134
3460	void noinline	4135	noinline
		4136	void
3461	ev_signal_start (EV_P_ ev_signal *w) EV_THROW	4137	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
3462	{	4138	{
3463	if (expect_false (ev_is_active (w)))	4139	if (expect_false (ev_is_active (w)))
3464	return;	4140	return;
3465		4141
3466	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4142	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
…		…
3468	#if EV_MULTIPLICITY	4144	#if EV_MULTIPLICITY
3469	assert (("libev: a signal must not be attached to two different loops",	4145	assert (("libev: a signal must not be attached to two different loops",
3470	!signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));	4146	!signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3471		4147
3472	signals [w->signum - 1].loop = EV_A;	4148	signals [w->signum - 1].loop = EV_A;
		4149	ECB_MEMORY_FENCE_RELEASE;
3473	#endif	4150	#endif
3474		4151
3475	EV_FREQUENT_CHECK;	4152	EV_FREQUENT_CHECK;
3476		4153
3477	#if EV_USE_SIGNALFD	4154	#if EV_USE_SIGNALFD
…		…
3536	}	4213	}
3537		4214
3538	EV_FREQUENT_CHECK;	4215	EV_FREQUENT_CHECK;
3539	}	4216	}
3540		4217
3541	void noinline	4218	noinline
		4219	void
3542	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW	4220	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
3543	{	4221	{
3544	clear_pending (EV_A_ (W)w);	4222	clear_pending (EV_A_ (W)w);
3545	if (expect_false (!ev_is_active (w)))	4223	if (expect_false (!ev_is_active (w)))
3546	return;	4224	return;
3547		4225
…		…
3578	#endif	4256	#endif
3579		4257
3580	#if EV_CHILD_ENABLE	4258	#if EV_CHILD_ENABLE
3581		4259
3582	void	4260	void
3583	ev_child_start (EV_P_ ev_child *w) EV_THROW	4261	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
3584	{	4262	{
3585	#if EV_MULTIPLICITY	4263	#if EV_MULTIPLICITY
3586	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4264	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3587	#endif	4265	#endif
3588	if (expect_false (ev_is_active (w)))	4266	if (expect_false (ev_is_active (w)))
…		…
3595		4273
3596	EV_FREQUENT_CHECK;	4274	EV_FREQUENT_CHECK;
3597	}	4275	}
3598		4276
3599	void	4277	void
3600	ev_child_stop (EV_P_ ev_child *w) EV_THROW	4278	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
3601	{	4279	{
3602	clear_pending (EV_A_ (W)w);	4280	clear_pending (EV_A_ (W)w);
3603	if (expect_false (!ev_is_active (w)))	4281	if (expect_false (!ev_is_active (w)))
3604	return;	4282	return;
3605		4283
…		…
3622		4300
3623	#define DEF_STAT_INTERVAL 5.0074891	4301	#define DEF_STAT_INTERVAL 5.0074891
3624	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4302	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
3625	#define MIN_STAT_INTERVAL 0.1074891	4303	#define MIN_STAT_INTERVAL 0.1074891
3626		4304
3627	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4305	noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
3628		4306
3629	#if EV_USE_INOTIFY	4307	#if EV_USE_INOTIFY
3630		4308
3631	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4309	/* 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)	4310	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3633		4311
3634	static void noinline	4312	noinline
		4313	static void
3635	infy_add (EV_P_ ev_stat *w)	4314	infy_add (EV_P_ ev_stat *w)
3636	{	4315	{
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);	4316	w->wd = inotify_add_watch (fs_fd, w->path,
		4317	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
		4318	| IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
		4319	| IN_DONT_FOLLOW | IN_MASK_ADD);
3638		4320
3639	if (w->wd >= 0)	4321	if (w->wd >= 0)
3640	{	4322	{
3641	struct statfs sfs;	4323	struct statfs sfs;
3642		4324
…		…
3646		4328
3647	if (!fs_2625)	4329	if (!fs_2625)
3648	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	4330	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3649	else if (!statfs (w->path, &sfs)	4331	else if (!statfs (w->path, &sfs)
3650	&& (sfs.f_type == 0x1373 /* devfs */	4332	&& (sfs.f_type == 0x1373 /* devfs */
		4333	|| sfs.f_type == 0x4006 /* fat */
		4334	|| sfs.f_type == 0x4d44 /* msdos */
3651	|| sfs.f_type == 0xEF53 /* ext2/3 */	4335	|| sfs.f_type == 0xEF53 /* ext2/3 */
		4336	|| sfs.f_type == 0x72b6 /* jffs2 */
		4337	|| sfs.f_type == 0x858458f6 /* ramfs */
		4338	|| sfs.f_type == 0x5346544e /* ntfs */
3652	|| sfs.f_type == 0x3153464a /* jfs */	4339	|| sfs.f_type == 0x3153464a /* jfs */
		4340	|| sfs.f_type == 0x9123683e /* btrfs */
3653	|| sfs.f_type == 0x52654973 /* reiser3 */	4341	|| sfs.f_type == 0x52654973 /* reiser3 */
3654	|| sfs.f_type == 0x01021994 /* tempfs */	4342	|| sfs.f_type == 0x01021994 /* tmpfs */
3655	|| sfs.f_type == 0x58465342 /* xfs */))	4343	|| sfs.f_type == 0x58465342 /* xfs */))
3656	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */	4344	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3657	else	4345	else
3658	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */	4346	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3659	}	4347	}
…		…
3694	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4382	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3695	ev_timer_again (EV_A_ &w->timer);	4383	ev_timer_again (EV_A_ &w->timer);
3696	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4384	if (ev_is_active (&w->timer)) ev_unref (EV_A);
3697	}	4385	}
3698		4386
3699	static void noinline	4387	noinline
		4388	static void
3700	infy_del (EV_P_ ev_stat *w)	4389	infy_del (EV_P_ ev_stat *w)
3701	{	4390	{
3702	int slot;	4391	int slot;
3703	int wd = w->wd;	4392	int wd = w->wd;
3704		4393
…		…
3711		4400
3712	/* remove this watcher, if others are watching it, they will rearm */	4401	/* remove this watcher, if others are watching it, they will rearm */
3713	inotify_rm_watch (fs_fd, wd);	4402	inotify_rm_watch (fs_fd, wd);
3714	}	4403	}
3715		4404
3716	static void noinline	4405	noinline
		4406	static void
3717	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4407	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
3718	{	4408	{
3719	if (slot < 0)	4409	if (slot < 0)
3720	/* overflow, need to check for all hash slots */	4410	/* overflow, need to check for all hash slots */
3721	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)	4411	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
…		…
3757	infy_wd (EV_A_ ev->wd, ev->wd, ev);	4447	infy_wd (EV_A_ ev->wd, ev->wd, ev);
3758	ofs += sizeof (struct inotify_event) + ev->len;	4448	ofs += sizeof (struct inotify_event) + ev->len;
3759	}	4449	}
3760	}	4450	}
3761		4451
3762	inline_size void ecb_cold	4452	inline_size ecb_cold
		4453	void
3763	ev_check_2625 (EV_P)	4454	ev_check_2625 (EV_P)
3764	{	4455	{
3765	/* kernels < 2.6.25 are borked	4456	/* kernels < 2.6.25 are borked
3766	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	4457	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
3767	*/	4458	*/
…		…
3857	#else	4548	#else
3858	# define EV_LSTAT(p,b) lstat (p, b)	4549	# define EV_LSTAT(p,b) lstat (p, b)
3859	#endif	4550	#endif
3860		4551
3861	void	4552	void
3862	ev_stat_stat (EV_P_ ev_stat *w) EV_THROW	4553	ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT
3863	{	4554	{
3864	if (lstat (w->path, &w->attr) < 0)	4555	if (lstat (w->path, &w->attr) < 0)
3865	w->attr.st_nlink = 0;	4556	w->attr.st_nlink = 0;
3866	else if (!w->attr.st_nlink)	4557	else if (!w->attr.st_nlink)
3867	w->attr.st_nlink = 1;	4558	w->attr.st_nlink = 1;
3868	}	4559	}
3869		4560
3870	static void noinline	4561	noinline
		4562	static void
3871	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4563	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3872	{	4564	{
3873	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4565	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
3874		4566
3875	ev_statdata prev = w->attr;	4567	ev_statdata prev = w->attr;
…		…
3906	ev_feed_event (EV_A_ w, EV_STAT);	4598	ev_feed_event (EV_A_ w, EV_STAT);
3907	}	4599	}
3908	}	4600	}
3909		4601
3910	void	4602	void
3911	ev_stat_start (EV_P_ ev_stat *w) EV_THROW	4603	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
3912	{	4604	{
3913	if (expect_false (ev_is_active (w)))	4605	if (expect_false (ev_is_active (w)))
3914	return;	4606	return;
3915		4607
3916	ev_stat_stat (EV_A_ w);	4608	ev_stat_stat (EV_A_ w);
…		…
3937		4629
3938	EV_FREQUENT_CHECK;	4630	EV_FREQUENT_CHECK;
3939	}	4631	}
3940		4632
3941	void	4633	void
3942	ev_stat_stop (EV_P_ ev_stat *w) EV_THROW	4634	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
3943	{	4635	{
3944	clear_pending (EV_A_ (W)w);	4636	clear_pending (EV_A_ (W)w);
3945	if (expect_false (!ev_is_active (w)))	4637	if (expect_false (!ev_is_active (w)))
3946	return;	4638	return;
3947		4639
…		…
3963	}	4655	}
3964	#endif	4656	#endif
3965		4657
3966	#if EV_IDLE_ENABLE	4658	#if EV_IDLE_ENABLE
3967	void	4659	void
3968	ev_idle_start (EV_P_ ev_idle *w) EV_THROW	4660	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
3969	{	4661	{
3970	if (expect_false (ev_is_active (w)))	4662	if (expect_false (ev_is_active (w)))
3971	return;	4663	return;
3972		4664
3973	pri_adjust (EV_A_ (W)w);	4665	pri_adjust (EV_A_ (W)w);
…		…
3978	int active = ++idlecnt [ABSPRI (w)];	4670	int active = ++idlecnt [ABSPRI (w)];
3979		4671
3980	++idleall;	4672	++idleall;
3981	ev_start (EV_A_ (W)w, active);	4673	ev_start (EV_A_ (W)w, active);
3982		4674
3983	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);	4675	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, array_needsize_noinit);
3984	idles [ABSPRI (w)][active - 1] = w;	4676	idles [ABSPRI (w)][active - 1] = w;
3985	}	4677	}
3986		4678
3987	EV_FREQUENT_CHECK;	4679	EV_FREQUENT_CHECK;
3988	}	4680	}
3989		4681
3990	void	4682	void
3991	ev_idle_stop (EV_P_ ev_idle *w) EV_THROW	4683	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
3992	{	4684	{
3993	clear_pending (EV_A_ (W)w);	4685	clear_pending (EV_A_ (W)w);
3994	if (expect_false (!ev_is_active (w)))	4686	if (expect_false (!ev_is_active (w)))
3995	return;	4687	return;
3996		4688
…		…
4010	}	4702	}
4011	#endif	4703	#endif
4012		4704
4013	#if EV_PREPARE_ENABLE	4705	#if EV_PREPARE_ENABLE
4014	void	4706	void
4015	ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW	4707	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4016	{	4708	{
4017	if (expect_false (ev_is_active (w)))	4709	if (expect_false (ev_is_active (w)))
4018	return;	4710	return;
4019		4711
4020	EV_FREQUENT_CHECK;	4712	EV_FREQUENT_CHECK;
4021		4713
4022	ev_start (EV_A_ (W)w, ++preparecnt);	4714	ev_start (EV_A_ (W)w, ++preparecnt);
4023	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);	4715	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, array_needsize_noinit);
4024	prepares [preparecnt - 1] = w;	4716	prepares [preparecnt - 1] = w;
4025		4717
4026	EV_FREQUENT_CHECK;	4718	EV_FREQUENT_CHECK;
4027	}	4719	}
4028		4720
4029	void	4721	void
4030	ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW	4722	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4031	{	4723	{
4032	clear_pending (EV_A_ (W)w);	4724	clear_pending (EV_A_ (W)w);
4033	if (expect_false (!ev_is_active (w)))	4725	if (expect_false (!ev_is_active (w)))
4034	return;	4726	return;
4035		4727
…		…
4048	}	4740	}
4049	#endif	4741	#endif
4050		4742
4051	#if EV_CHECK_ENABLE	4743	#if EV_CHECK_ENABLE
4052	void	4744	void
4053	ev_check_start (EV_P_ ev_check *w) EV_THROW	4745	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4054	{	4746	{
4055	if (expect_false (ev_is_active (w)))	4747	if (expect_false (ev_is_active (w)))
4056	return;	4748	return;
4057		4749
4058	EV_FREQUENT_CHECK;	4750	EV_FREQUENT_CHECK;
4059		4751
4060	ev_start (EV_A_ (W)w, ++checkcnt);	4752	ev_start (EV_A_ (W)w, ++checkcnt);
4061	array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);	4753	array_needsize (ev_check *, checks, checkmax, checkcnt, array_needsize_noinit);
4062	checks [checkcnt - 1] = w;	4754	checks [checkcnt - 1] = w;
4063		4755
4064	EV_FREQUENT_CHECK;	4756	EV_FREQUENT_CHECK;
4065	}	4757	}
4066		4758
4067	void	4759	void
4068	ev_check_stop (EV_P_ ev_check *w) EV_THROW	4760	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4069	{	4761	{
4070	clear_pending (EV_A_ (W)w);	4762	clear_pending (EV_A_ (W)w);
4071	if (expect_false (!ev_is_active (w)))	4763	if (expect_false (!ev_is_active (w)))
4072	return;	4764	return;
4073		4765
…		…
4085	EV_FREQUENT_CHECK;	4777	EV_FREQUENT_CHECK;
4086	}	4778	}
4087	#endif	4779	#endif
4088		4780
4089	#if EV_EMBED_ENABLE	4781	#if EV_EMBED_ENABLE
4090	void noinline	4782	noinline
		4783	void
4091	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW	4784	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4092	{	4785	{
4093	ev_run (w->other, EVRUN_NOWAIT);	4786	ev_run (w->other, EVRUN_NOWAIT);
4094	}	4787	}
4095		4788
4096	static void	4789	static void
…		…
4144	ev_idle_stop (EV_A_ idle);	4837	ev_idle_stop (EV_A_ idle);
4145	}	4838	}
4146	#endif	4839	#endif
4147		4840
4148	void	4841	void
4149	ev_embed_start (EV_P_ ev_embed *w) EV_THROW	4842	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4150	{	4843	{
4151	if (expect_false (ev_is_active (w)))	4844	if (expect_false (ev_is_active (w)))
4152	return;	4845	return;
4153		4846
4154	{	4847	{
…		…
4175		4868
4176	EV_FREQUENT_CHECK;	4869	EV_FREQUENT_CHECK;
4177	}	4870	}
4178		4871
4179	void	4872	void
4180	ev_embed_stop (EV_P_ ev_embed *w) EV_THROW	4873	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4181	{	4874	{
4182	clear_pending (EV_A_ (W)w);	4875	clear_pending (EV_A_ (W)w);
4183	if (expect_false (!ev_is_active (w)))	4876	if (expect_false (!ev_is_active (w)))
4184	return;	4877	return;
4185		4878
…		…
4195	}	4888	}
4196	#endif	4889	#endif
4197		4890
4198	#if EV_FORK_ENABLE	4891	#if EV_FORK_ENABLE
4199	void	4892	void
4200	ev_fork_start (EV_P_ ev_fork *w) EV_THROW	4893	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4201	{	4894	{
4202	if (expect_false (ev_is_active (w)))	4895	if (expect_false (ev_is_active (w)))
4203	return;	4896	return;
4204		4897
4205	EV_FREQUENT_CHECK;	4898	EV_FREQUENT_CHECK;
4206		4899
4207	ev_start (EV_A_ (W)w, ++forkcnt);	4900	ev_start (EV_A_ (W)w, ++forkcnt);
4208	array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);	4901	array_needsize (ev_fork *, forks, forkmax, forkcnt, array_needsize_noinit);
4209	forks [forkcnt - 1] = w;	4902	forks [forkcnt - 1] = w;
4210		4903
4211	EV_FREQUENT_CHECK;	4904	EV_FREQUENT_CHECK;
4212	}	4905	}
4213		4906
4214	void	4907	void
4215	ev_fork_stop (EV_P_ ev_fork *w) EV_THROW	4908	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4216	{	4909	{
4217	clear_pending (EV_A_ (W)w);	4910	clear_pending (EV_A_ (W)w);
4218	if (expect_false (!ev_is_active (w)))	4911	if (expect_false (!ev_is_active (w)))
4219	return;	4912	return;
4220		4913
…		…
4233	}	4926	}
4234	#endif	4927	#endif
4235		4928
4236	#if EV_CLEANUP_ENABLE	4929	#if EV_CLEANUP_ENABLE
4237	void	4930	void
4238	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW	4931	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4239	{	4932	{
4240	if (expect_false (ev_is_active (w)))	4933	if (expect_false (ev_is_active (w)))
4241	return;	4934	return;
4242		4935
4243	EV_FREQUENT_CHECK;	4936	EV_FREQUENT_CHECK;
4244		4937
4245	ev_start (EV_A_ (W)w, ++cleanupcnt);	4938	ev_start (EV_A_ (W)w, ++cleanupcnt);
4246	array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2);	4939	array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, array_needsize_noinit);
4247	cleanups [cleanupcnt - 1] = w;	4940	cleanups [cleanupcnt - 1] = w;
4248		4941
4249	/* cleanup watchers should never keep a refcount on the loop */	4942	/* cleanup watchers should never keep a refcount on the loop */
4250	ev_unref (EV_A);	4943	ev_unref (EV_A);
4251	EV_FREQUENT_CHECK;	4944	EV_FREQUENT_CHECK;
4252	}	4945	}
4253		4946
4254	void	4947	void
4255	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW	4948	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4256	{	4949	{
4257	clear_pending (EV_A_ (W)w);	4950	clear_pending (EV_A_ (W)w);
4258	if (expect_false (!ev_is_active (w)))	4951	if (expect_false (!ev_is_active (w)))
4259	return;	4952	return;
4260		4953
…		…
4274	}	4967	}
4275	#endif	4968	#endif
4276		4969
4277	#if EV_ASYNC_ENABLE	4970	#if EV_ASYNC_ENABLE
4278	void	4971	void
4279	ev_async_start (EV_P_ ev_async *w) EV_THROW	4972	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4280	{	4973	{
4281	if (expect_false (ev_is_active (w)))	4974	if (expect_false (ev_is_active (w)))
4282	return;	4975	return;
4283		4976
4284	w->sent = 0;	4977	w->sent = 0;
…		…
4286	evpipe_init (EV_A);	4979	evpipe_init (EV_A);
4287		4980
4288	EV_FREQUENT_CHECK;	4981	EV_FREQUENT_CHECK;
4289		4982
4290	ev_start (EV_A_ (W)w, ++asynccnt);	4983	ev_start (EV_A_ (W)w, ++asynccnt);
4291	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);	4984	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, array_needsize_noinit);
4292	asyncs [asynccnt - 1] = w;	4985	asyncs [asynccnt - 1] = w;
4293		4986
4294	EV_FREQUENT_CHECK;	4987	EV_FREQUENT_CHECK;
4295	}	4988	}
4296		4989
4297	void	4990	void
4298	ev_async_stop (EV_P_ ev_async *w) EV_THROW	4991	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4299	{	4992	{
4300	clear_pending (EV_A_ (W)w);	4993	clear_pending (EV_A_ (W)w);
4301	if (expect_false (!ev_is_active (w)))	4994	if (expect_false (!ev_is_active (w)))
4302	return;	4995	return;
4303		4996
…		…
4314		5007
4315	EV_FREQUENT_CHECK;	5008	EV_FREQUENT_CHECK;
4316	}	5009	}
4317		5010
4318	void	5011	void
4319	ev_async_send (EV_P_ ev_async *w) EV_THROW	5012	ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT
4320	{	5013	{
4321	w->sent = 1;	5014	w->sent = 1;
4322	evpipe_write (EV_A_ &async_pending);	5015	evpipe_write (EV_A_ &async_pending);
4323	}	5016	}
4324	#endif	5017	#endif
…		…
4361		5054
4362	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));	5055	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4363	}	5056	}
4364		5057
4365	void	5058	void
4366	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW	5059	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT
4367	{	5060	{
4368	struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));	5061	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		5062
4376	once->cb = cb;	5063	once->cb = cb;
4377	once->arg = arg;	5064	once->arg = arg;
4378		5065
4379	ev_init (&once->io, once_cb_io);	5066	ev_init (&once->io, once_cb_io);
…		…
4392	}	5079	}
4393		5080
4394	/*****************************************************************************/	5081	/*****************************************************************************/
4395		5082
4396	#if EV_WALK_ENABLE	5083	#if EV_WALK_ENABLE
4397	void ecb_cold	5084	ecb_cold
		5085	void
4398	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW	5086	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT
4399	{	5087	{
4400	int i, j;	5088	int i, j;
4401	ev_watcher_list *wl, *wn;	5089	ev_watcher_list *wl, *wn;
4402		5090
4403	if (types & (EV_IO | EV_EMBED))	5091	if (types & (EV_IO | EV_EMBED))

Diff Legend

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