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

Comparing libev/ev.c (file contents):
Revision 1.384 by root, Wed Jul 20 00:58:45 2011 UTC vs.
Revision 1.392 by root, Thu Aug 4 14:37:49 2011 UTC

…		…
464	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	464	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
465		465
466	#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)	466	#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
467	#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)	467	#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
468		468
469	/* the following are taken from libecb */	469	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
470	/* ecb.h start */	470	/* ECB.H BEGIN */
		471	/*
		472	* libecb - http://software.schmorp.de/pkg/libecb
		473	*
		474	* Copyright (©) 2009-2011 Marc Alexander Lehmann <libecb@schmorp.de>
		475	* Copyright (©) 2011 Emanuele Giaquinta
		476	* All rights reserved.
		477	*
		478	* Redistribution and use in source and binary forms, with or without modifica-
		479	* tion, are permitted provided that the following conditions are met:
		480	*
		481	* 1. Redistributions of source code must retain the above copyright notice,
		482	* this list of conditions and the following disclaimer.
		483	*
		484	* 2. Redistributions in binary form must reproduce the above copyright
		485	* notice, this list of conditions and the following disclaimer in the
		486	* documentation and/or other materials provided with the distribution.
		487	*
		488	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
		489	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
		490	* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
		491	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
		492	* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		493	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
		494	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
		495	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
		496	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
		497	* OF THE POSSIBILITY OF SUCH DAMAGE.
		498	*/
		499
		500	#ifndef ECB_H
		501	#define ECB_H
		502
		503	#ifdef _WIN32
		504	typedef signed char int8_t;
		505	typedef unsigned char uint8_t;
		506	typedef signed short int16_t;
		507	typedef unsigned short uint16_t;
		508	typedef signed int int32_t;
		509	typedef unsigned int uint32_t;
		510	#if __GNUC__
		511	typedef signed long long int64_t;
		512	typedef unsigned long long uint64_t;
		513	#else /* _MSC_VER \|\| __BORLANDC__ */
		514	typedef signed __int64 int64_t;
		515	typedef unsigned __int64 uint64_t;
		516	#endif
		517	#else
		518	#include <inttypes.h>
		519	#endif
471		520
472	/* many compilers define _GNUC_ to some versions but then only implement	521	/* many compilers define _GNUC_ to some versions but then only implement
473	* what their idiot authors think are the "more important" extensions,	522	* what their idiot authors think are the "more important" extensions,
474	* causing enourmous grief in return for some better fake benchmark numbers.	523	* causing enormous grief in return for some better fake benchmark numbers.
475	* or so.	524	* or so.
476	* we try to detect these and simply assume they are not gcc - if they have	525	* we try to detect these and simply assume they are not gcc - if they have
477	* an issue with that they should have done it right in the first place.	526	* an issue with that they should have done it right in the first place.
478	*/	527	*/
479	#ifndef ECB_GCC_VERSION	528	#ifndef ECB_GCC_VERSION
…		…
482	#else	531	#else
483	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) \|\| (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))	532	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) \|\| (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
484	#endif	533	#endif
485	#endif	534	#endif
486		535
		536	/*****************************************************************************/
		537
		538	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
		539	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
		540
		541	#if ECB_NO_THREADS \|\| ECB_NO_SMP
		542	#define ECB_MEMORY_FENCE do { } while (0)
		543	#define ECB_MEMORY_FENCE_ACQUIRE do { } while (0)
		544	#define ECB_MEMORY_FENCE_RELEASE do { } while (0)
		545	#endif
		546
		547	#ifndef ECB_MEMORY_FENCE
		548	#if ECB_GCC_VERSION(2,5)
		549	#if __x86
		550	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
		551	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */
		552	#define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */
		553	#elif __amd64
		554	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
		555	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")
		556	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */
		557	#elif __powerpc__ \|\| __ppc__ \|\| __powerpc64__ \|\| __ppc64__
		558	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
		559	#elif defined(__ARM_ARCH_6__ ) \|\| defined(__ARM_ARCH_6J__ ) \
		560	\|\| defined(__ARM_ARCH_6K__) \|\| defined(__ARM_ARCH_6ZK__) \
		561	\|\| defined(__ARM_ARCH_7__ ) \|\| defined(__ARM_ARCH_7A__ ) \
		562	\|\| defined(__ARM_ARCH_7M__) \|\| defined(__ARM_ARCH_7R__ )
		563	#define ECB_MEMORY_FENCE \
		564	do { \
		565	int null = 0; \
		566	__asm__ __volatile__ ("mcr p15,0,%0,c6,c10,5", : "=&r" (null) : : "memory"); \
		567	while (0)
		568	#endif
		569	#endif
		570	#endif
		571
		572	#ifndef ECB_MEMORY_FENCE
		573	#if ECB_GCC_VERSION(4,4) \|\| defined(__INTEL_COMPILER)
		574	#define ECB_MEMORY_FENCE __sync_synchronize ()
		575	/#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) /
		576	/#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) /
		577	#elif _MSC_VER >= 1400 /* VC++ 2005 */
		578	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
		579	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()
		580	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
		581	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
		582	#elif defined(_WIN32)
		583	#include <WinNT.h>
		584	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
		585	#endif
		586	#endif
		587
		588	#ifndef ECB_MEMORY_FENCE
		589	#if !ECB_AVOID_PTHREADS
		590	/*
		591	* if you get undefined symbol references to pthread_mutex_lock,
		592	* or failure to find pthread.h, then you should implement
		593	* the ECB_MEMORY_FENCE operations for your cpu/compiler
		594	* OR provide pthread.h and link against the posix thread library
		595	* of your system.
		596	*/
		597	#include <pthread.h>
		598	#define ECB_NEEDS_PTHREADS 1
		599	#define ECB_MEMORY_FENCE_NEEDS_PTHREADS 1
		600
		601	static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
		602	#define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
		603	#endif
		604	#endif
		605
		606	#if !defined(ECB_MEMORY_FENCE_ACQUIRE) && defined(ECB_MEMORY_FENCE)
		607	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
		608	#endif
		609
		610	#if !defined(ECB_MEMORY_FENCE_RELEASE) && defined(ECB_MEMORY_FENCE)
		611	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
		612	#endif
		613
		614	/*****************************************************************************/
		615
		616	#define ECB_C99 (__STDC_VERSION__ >= 199901L)
		617
487	#if __cplusplus	618	#if __cplusplus
488	#define ecb_inline static inline	619	#define ecb_inline static inline
489	#elif ECB_GCC_VERSION(2,5)	620	#elif ECB_GCC_VERSION(2,5)
490	#define ecb_inline static __inline__	621	#define ecb_inline static __inline__
491	#elif ECB_C99	622	#elif ECB_C99
492	#define ecb_inline static inline	623	#define ecb_inline static inline
493	#else	624	#else
494	#define ecb_inline static	625	#define ecb_inline static
495	#endif	626	#endif
496		627
497	#ifndef ECB_MEMORY_FENCE
498	#if ECB_GCC_VERSION(2,5)	628	#if ECB_GCC_VERSION(3,3)
499	#if __x86	629	#define ecb_restrict __restrict__
500	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")	630	#elif ECB_C99
501	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	631	#define ecb_restrict restrict
502	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE /* better be safe than sorry */	632	#else
503	#elif __amd64	633	#define ecb_restrict
504	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
505	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")
506	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence")
507	#endif
508	#endif	634	#endif
509	#endif
510		635
511	#ifndef ECB_MEMORY_FENCE	636	typedef int ecb_bool;
512	#if ECB_GCC_VERSION(4,4)
513	#define ECB_MEMORY_FENCE __sync_synchronize ()
514	#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); })
515	#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); })
516	#elif _MSC_VER >= 1400
517	#define ECB_MEMORY_FENCE do { } while (0)
518	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
519	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
520	#elif defined(_WIN32) && defined(MemoryBarrier)
521	#define ECB_MEMORY_FENCE MemoryBarrier ()
522	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
523	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
524	#endif
525	#endif
526		637
527	#ifndef ECB_MEMORY_FENCE	638	#define ECB_CONCAT_(a, b) a ## b
528	#include <pthread.h>	639	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
		640	#define ECB_STRINGIFY_(a) # a
		641	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
529		642
530	static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;	643	#define ecb_function_ ecb_inline
531	#define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
532	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
533	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
534	#endif
535		644
536	#if ECB_GCC_VERSION(3,1)	645	#if ECB_GCC_VERSION(3,1)
537	#define ecb_attribute(attrlist) __attribute__(attrlist)	646	#define ecb_attribute(attrlist) __attribute__(attrlist)
538	#define ecb_is_constant(expr) __builtin_constant_p (expr)	647	#define ecb_is_constant(expr) __builtin_constant_p (expr)
539	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))	648	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
…		…
543	#define ecb_is_constant(expr) 0	652	#define ecb_is_constant(expr) 0
544	#define ecb_expect(expr,value) (expr)	653	#define ecb_expect(expr,value) (expr)
545	#define ecb_prefetch(addr,rw,locality)	654	#define ecb_prefetch(addr,rw,locality)
546	#endif	655	#endif
547		656
		657	/* no emulation for ecb_decltype */
		658	#if ECB_GCC_VERSION(4,5)
		659	#define ecb_decltype(x) __decltype(x)
		660	#elif ECB_GCC_VERSION(3,0)
		661	#define ecb_decltype(x) __typeof(x)
		662	#endif
		663
548	#define ecb_noinline ecb_attribute ((__noinline__))	664	#define ecb_noinline ecb_attribute ((__noinline__))
549	#define ecb_noreturn ecb_attribute ((__noreturn__))	665	#define ecb_noreturn ecb_attribute ((__noreturn__))
550	#define ecb_unused ecb_attribute ((__unused__))	666	#define ecb_unused ecb_attribute ((__unused__))
551	#define ecb_const ecb_attribute ((__const__))	667	#define ecb_const ecb_attribute ((__const__))
552	#define ecb_pure ecb_attribute ((__pure__))	668	#define ecb_pure ecb_attribute ((__pure__))
…		…
564	/* put around conditional expressions if you are very sure that the */	680	/* put around conditional expressions if you are very sure that the */
565	/* expression is mostly true or mostly false. note that these return */	681	/* expression is mostly true or mostly false. note that these return */
566	/* booleans, not the expression. */	682	/* booleans, not the expression. */
567	#define ecb_expect_false(expr) ecb_expect (!!(expr), 0)	683	#define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
568	#define ecb_expect_true(expr) ecb_expect (!!(expr), 1)	684	#define ecb_expect_true(expr) ecb_expect (!!(expr), 1)
569	/* ecb.h end */	685	/* for compatibility to the rest of the world */
		686	#define ecb_likely(expr) ecb_expect_true (expr)
		687	#define ecb_unlikely(expr) ecb_expect_false (expr)
		688
		689	/* count trailing zero bits and count # of one bits */
		690	#if ECB_GCC_VERSION(3,4)
		691	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
		692	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)
		693	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
		694	#define ecb_ctz32(x) __builtin_ctz (x)
		695	#define ecb_ctz64(x) __builtin_ctzll (x)
		696	#define ecb_popcount32(x) __builtin_popcount (x)
		697	/* no popcountll */
		698	#else
		699	ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;
		700	ecb_function_ int
		701	ecb_ctz32 (uint32_t x)
		702	{
		703	int r = 0;
		704
		705	x &= ~x + 1; /* this isolates the lowest bit */
		706
		707	#if ECB_branchless_on_i386
		708	r += !!(x & 0xaaaaaaaa) << 0;
		709	r += !!(x & 0xcccccccc) << 1;
		710	r += !!(x & 0xf0f0f0f0) << 2;
		711	r += !!(x & 0xff00ff00) << 3;
		712	r += !!(x & 0xffff0000) << 4;
		713	#else
		714	if (x & 0xaaaaaaaa) r += 1;
		715	if (x & 0xcccccccc) r += 2;
		716	if (x & 0xf0f0f0f0) r += 4;
		717	if (x & 0xff00ff00) r += 8;
		718	if (x & 0xffff0000) r += 16;
		719	#endif
		720
		721	return r;
		722	}
		723
		724	ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;
		725	ecb_function_ int
		726	ecb_ctz64 (uint64_t x)
		727	{
		728	int shift = x & 0xffffffffU ? 0 : 32;
		729	return ecb_ctz32 (x >> shift) + shift;
		730	}
		731
		732	ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;
		733	ecb_function_ int
		734	ecb_popcount32 (uint32_t x)
		735	{
		736	x -= (x >> 1) & 0x55555555;
		737	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
		738	x = ((x >> 4) + x) & 0x0f0f0f0f;
		739	x *= 0x01010101;
		740
		741	return x >> 24;
		742	}
		743
		744	ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;
		745	ecb_function_ int ecb_ld32 (uint32_t x)
		746	{
		747	int r = 0;
		748
		749	if (x >> 16) { x >>= 16; r += 16; }
		750	if (x >> 8) { x >>= 8; r += 8; }
		751	if (x >> 4) { x >>= 4; r += 4; }
		752	if (x >> 2) { x >>= 2; r += 2; }
		753	if (x >> 1) { r += 1; }
		754
		755	return r;
		756	}
		757
		758	ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;
		759	ecb_function_ int ecb_ld64 (uint64_t x)
		760	{
		761	int r = 0;
		762
		763	if (x >> 32) { x >>= 32; r += 32; }
		764
		765	return r + ecb_ld32 (x);
		766	}
		767	#endif
		768
		769	/* popcount64 is only available on 64 bit cpus as gcc builtin */
		770	/* so for this version we are lazy */
		771	ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
		772	ecb_function_ int
		773	ecb_popcount64 (uint64_t x)
		774	{
		775	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
		776	}
		777
		778	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;
		779	ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;
		780	ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;
		781	ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;
		782	ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;
		783	ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;
		784	ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;
		785	ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;
		786
		787	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) \| (x << count); }
		788	ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) \| (x >> count); }
		789	ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) \| (x << count); }
		790	ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) \| (x >> count); }
		791	ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) \| (x << count); }
		792	ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) \| (x >> count); }
		793	ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) \| (x << count); }
		794	ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) \| (x >> count); }
		795
		796	#if ECB_GCC_VERSION(4,3)
		797	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
		798	#define ecb_bswap32(x) __builtin_bswap32 (x)
		799	#define ecb_bswap64(x) __builtin_bswap64 (x)
		800	#else
		801	ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;
		802	ecb_function_ uint16_t
		803	ecb_bswap16 (uint16_t x)
		804	{
		805	return ecb_rotl16 (x, 8);
		806	}
		807
		808	ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;
		809	ecb_function_ uint32_t
		810	ecb_bswap32 (uint32_t x)
		811	{
		812	return (((uint32_t)ecb_bswap16 (x)) << 16) \| ecb_bswap16 (x >> 16);
		813	}
		814
		815	ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;
		816	ecb_function_ uint64_t
		817	ecb_bswap64 (uint64_t x)
		818	{
		819	return (((uint64_t)ecb_bswap32 (x)) << 32) \| ecb_bswap32 (x >> 32);
		820	}
		821	#endif
		822
		823	#if ECB_GCC_VERSION(4,5)
		824	#define ecb_unreachable() __builtin_unreachable ()
		825	#else
		826	/* this seems to work fine, but gcc always emits a warning for it :/ */
		827	ecb_function_ void ecb_unreachable (void) ecb_noreturn;
		828	ecb_function_ void ecb_unreachable (void) { }
		829	#endif
		830
		831	/* try to tell the compiler that some condition is definitely true */
		832	#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)
		833
		834	ecb_function_ unsigned char ecb_byteorder_helper (void) ecb_const;
		835	ecb_function_ unsigned char
		836	ecb_byteorder_helper (void)
		837	{
		838	const uint32_t u = 0x11223344;
		839	return (unsigned char )&u;
		840	}
		841
		842	ecb_function_ ecb_bool ecb_big_endian (void) ecb_const;
		843	ecb_function_ ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
		844	ecb_function_ ecb_bool ecb_little_endian (void) ecb_const;
		845	ecb_function_ ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
		846
		847	#if ECB_GCC_VERSION(3,0) \|\| ECB_C99
		848	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
		849	#else
		850	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
		851	#endif
		852
		853	#if ecb_cplusplus_does_not_suck
		854	/* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
		855	template<typename T, int N>
		856	static inline int ecb_array_length (const T (&arr)[N])
		857	{
		858	return N;
		859	}
		860	#else
		861	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
		862	#endif
		863
		864	#endif
		865
		866	/* ECB.H END */
		867
		868	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
		869	# undef ECB_MEMORY_FENCE
		870	# undef ECB_MEMORY_FENCE_ACQUIRE
		871	# undef ECB_MEMORY_FENCE_RELEASE
		872	#endif
570		873
571	#define expect_false(cond) ecb_expect_false (cond)	874	#define expect_false(cond) ecb_expect_false (cond)
572	#define expect_true(cond) ecb_expect_true (cond)	875	#define expect_true(cond) ecb_expect_true (cond)
573	#define noinline ecb_noinline	876	#define noinline ecb_noinline
574		877
…		…
1474		1777
1475	if (pipe_write_wanted)	1778	if (pipe_write_wanted)
1476	{	1779	{
1477	int old_errno;	1780	int old_errno;
1478		1781
1479	pipe_write_skipped = 0; /* just an optimsiation, no fence needed */	1782	pipe_write_skipped = 0; /* just an optimisation, no fence needed */
1480		1783
1481	old_errno = errno; /* save errno because write will clobber it */	1784	old_errno = errno; /* save errno because write will clobber it */
1482		1785
1483	#if EV_USE_EVENTFD	1786	#if EV_USE_EVENTFD
1484	if (evfd >= 0)	1787	if (evfd >= 0)
…		…
2616	time_update (EV_A_ 1e100);	2919	time_update (EV_A_ 1e100);
2617		2920
2618	/* from now on, we want a pipe-wake-up */	2921	/* from now on, we want a pipe-wake-up */
2619	pipe_write_wanted = 1;	2922	pipe_write_wanted = 1;
2620		2923
2621	ECB_MEMORY_FENCE; /* amke sure pipe_write_wanted is visible before we check for potential skips */	2924	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
2622		2925
2623	if (expect_true (!(flags & EVRUN_NOWAIT \|\| idleall \|\| !activecnt \|\| pipe_write_skipped)))	2926	if (expect_true (!(flags & EVRUN_NOWAIT \|\| idleall \|\| !activecnt \|\| pipe_write_skipped)))
2624	{	2927	{
2625	waittime = MAX_BLOCKTIME;	2928	waittime = MAX_BLOCKTIME;
2626		2929
…		…
4028	cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));	4331	cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
4029	#endif	4332	#endif
4030		4333
4031	#if EV_IDLE_ENABLE	4334	#if EV_IDLE_ENABLE
4032	if (types & EV_IDLE)	4335	if (types & EV_IDLE)
4033	for (j = NUMPRI; i--; )	4336	for (j = NUMPRI; j--; )
4034	for (i = idlecnt [j]; i--; )	4337	for (i = idlecnt [j]; i--; )
4035	cb (EV_A_ EV_IDLE, idles [j][i]);	4338	cb (EV_A_ EV_IDLE, idles [j][i]);
4036	#endif	4339	#endif
4037		4340
4038	#if EV_FORK_ENABLE	4341	#if EV_FORK_ENABLE

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.384 by root, Wed Jul 20 00:58:45 2011 UTC vs. Revision 1.392 by root, Thu Aug 4 14:37:49 2011 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.384 by root, Wed Jul 20 00:58:45 2011 UTC vs.
Revision 1.392 by root, Thu Aug 4 14:37:49 2011 UTC