ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.380 by root, Mon Jun 27 19:20:01 2011 UTC vs.
Revision 1.424 by root, Tue May 1 22:01:40 2012 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 Marc Alexander Lehmann <libev@schmorp.de> 4 * Copyright (c) 2007,2008,2009,2010,2011,2012 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 *
59# endif 59# endif
60# ifndef EV_USE_MONOTONIC 60# ifndef EV_USE_MONOTONIC
61# define EV_USE_MONOTONIC 1 61# define EV_USE_MONOTONIC 1
62# endif 62# endif
63# endif 63# endif
64# elif !defined(EV_USE_CLOCK_SYSCALL) 64# elif !defined EV_USE_CLOCK_SYSCALL
65# define EV_USE_CLOCK_SYSCALL 0 65# define EV_USE_CLOCK_SYSCALL 0
66# endif 66# endif
67 67
68# if HAVE_CLOCK_GETTIME 68# if HAVE_CLOCK_GETTIME
69# ifndef EV_USE_MONOTONIC 69# ifndef EV_USE_MONOTONIC
183# include EV_H 183# include EV_H
184#else 184#else
185# include "ev.h" 185# include "ev.h"
186#endif 186#endif
187 187
188EV_CPP(extern "C" {) 188#if EV_NO_THREADS
189# undef EV_NO_SMP
190# define EV_NO_SMP 1
191# undef ECB_NO_THREADS
192# define ECB_NO_THREADS 1
193#endif
194#if EV_NO_SMP
195# undef EV_NO_SMP
196# define ECB_NO_SMP 1
197#endif
189 198
190#ifndef _WIN32 199#ifndef _WIN32
191# include <sys/time.h> 200# include <sys/time.h>
192# include <sys/wait.h> 201# include <sys/wait.h>
193# include <unistd.h> 202# include <unistd.h>
210#define _DARWIN_UNLIMITED_SELECT 1 219#define _DARWIN_UNLIMITED_SELECT 1
211 220
212/* this block tries to deduce configuration from header-defined symbols and defaults */ 221/* this block tries to deduce configuration from header-defined symbols and defaults */
213 222
214/* try to deduce the maximum number of signals on this platform */ 223/* try to deduce the maximum number of signals on this platform */
215#if defined (EV_NSIG) 224#if defined EV_NSIG
216/* use what's provided */ 225/* use what's provided */
217#elif defined (NSIG) 226#elif defined NSIG
218# define EV_NSIG (NSIG) 227# define EV_NSIG (NSIG)
219#elif defined(_NSIG) 228#elif defined _NSIG
220# define EV_NSIG (_NSIG) 229# define EV_NSIG (_NSIG)
221#elif defined (SIGMAX) 230#elif defined SIGMAX
222# define EV_NSIG (SIGMAX+1) 231# define EV_NSIG (SIGMAX+1)
223#elif defined (SIG_MAX) 232#elif defined SIG_MAX
224# define EV_NSIG (SIG_MAX+1) 233# define EV_NSIG (SIG_MAX+1)
225#elif defined (_SIG_MAX) 234#elif defined _SIG_MAX
226# define EV_NSIG (_SIG_MAX+1) 235# define EV_NSIG (_SIG_MAX+1)
227#elif defined (MAXSIG) 236#elif defined MAXSIG
228# define EV_NSIG (MAXSIG+1) 237# define EV_NSIG (MAXSIG+1)
229#elif defined (MAX_SIG) 238#elif defined MAX_SIG
230# define EV_NSIG (MAX_SIG+1) 239# define EV_NSIG (MAX_SIG+1)
231#elif defined (SIGARRAYSIZE) 240#elif defined SIGARRAYSIZE
232# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */ 241# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
233#elif defined (_sys_nsig) 242#elif defined _sys_nsig
234# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */ 243# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
235#else 244#else
236# error "unable to find value for NSIG, please report" 245# error "unable to find value for NSIG, please report"
237/* to make it compile regardless, just remove the above line, */ 246/* to make it compile regardless, just remove the above line, */
238/* but consider reporting it, too! :) */ 247/* but consider reporting it, too! :) */
250# define EV_USE_CLOCK_SYSCALL 0 259# define EV_USE_CLOCK_SYSCALL 0
251# endif 260# endif
252#endif 261#endif
253 262
254#ifndef EV_USE_MONOTONIC 263#ifndef EV_USE_MONOTONIC
255# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 264# if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
256# define EV_USE_MONOTONIC EV_FEATURE_OS 265# define EV_USE_MONOTONIC EV_FEATURE_OS
257# else 266# else
258# define EV_USE_MONOTONIC 0 267# define EV_USE_MONOTONIC 0
259# endif 268# endif
260#endif 269#endif
350#endif 359#endif
351 360
352/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */ 361/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
353/* which makes programs even slower. might work on other unices, too. */ 362/* which makes programs even slower. might work on other unices, too. */
354#if EV_USE_CLOCK_SYSCALL 363#if EV_USE_CLOCK_SYSCALL
355# include <syscall.h> 364# include <sys/syscall.h>
356# ifdef SYS_clock_gettime 365# ifdef SYS_clock_gettime
357# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts)) 366# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
358# undef EV_USE_MONOTONIC 367# undef EV_USE_MONOTONIC
359# define EV_USE_MONOTONIC 1 368# define EV_USE_MONOTONIC 1
360# else 369# else
386# define EV_USE_INOTIFY 0 395# define EV_USE_INOTIFY 0
387#endif 396#endif
388 397
389#if !EV_USE_NANOSLEEP 398#if !EV_USE_NANOSLEEP
390/* hp-ux has it in sys/time.h, which we unconditionally include above */ 399/* hp-ux has it in sys/time.h, which we unconditionally include above */
391# if !defined(_WIN32) && !defined(__hpux) 400# if !defined _WIN32 && !defined __hpux
392# include <sys/select.h> 401# include <sys/select.h>
393# endif 402# endif
394#endif 403#endif
395 404
396#if EV_USE_INOTIFY 405#if EV_USE_INOTIFY
464#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */ 473#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
465 474
466#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0) 475#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) 476#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
468 477
469/* the following are taken from libecb */ 478/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
470/* ecb.h start */ 479/* ECB.H BEGIN */
480/*
481 * libecb - http://software.schmorp.de/pkg/libecb
482 *
483 * Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>
484 * Copyright (©) 2011 Emanuele Giaquinta
485 * All rights reserved.
486 *
487 * Redistribution and use in source and binary forms, with or without modifica-
488 * tion, are permitted provided that the following conditions are met:
489 *
490 * 1. Redistributions of source code must retain the above copyright notice,
491 * this list of conditions and the following disclaimer.
492 *
493 * 2. Redistributions in binary form must reproduce the above copyright
494 * notice, this list of conditions and the following disclaimer in the
495 * documentation and/or other materials provided with the distribution.
496 *
497 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
498 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
499 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
500 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
501 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
502 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
503 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
504 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
505 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
506 * OF THE POSSIBILITY OF SUCH DAMAGE.
507 */
508
509#ifndef ECB_H
510#define ECB_H
511
512#ifdef _WIN32
513 typedef signed char int8_t;
514 typedef unsigned char uint8_t;
515 typedef signed short int16_t;
516 typedef unsigned short uint16_t;
517 typedef signed int int32_t;
518 typedef unsigned int uint32_t;
519 #if __GNUC__
520 typedef signed long long int64_t;
521 typedef unsigned long long uint64_t;
522 #else /* _MSC_VER || __BORLANDC__ */
523 typedef signed __int64 int64_t;
524 typedef unsigned __int64 uint64_t;
525 #endif
526#else
527 #include <inttypes.h>
528#endif
471 529
472/* many compilers define _GNUC_ to some versions but then only implement 530/* many compilers define _GNUC_ to some versions but then only implement
473 * what their idiot authors think are the "more important" extensions, 531 * what their idiot authors think are the "more important" extensions,
474 * causing enourmous grief in return for some better fake benchmark numbers. 532 * causing enormous grief in return for some better fake benchmark numbers.
475 * or so. 533 * or so.
476 * we try to detect these and simply assume they are not gcc - if they have 534 * 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. 535 * an issue with that they should have done it right in the first place.
478 */ 536 */
479#ifndef ECB_GCC_VERSION 537#ifndef ECB_GCC_VERSION
480 #if !defined(__GNUC_MINOR__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) || defined(__llvm__) || defined(__clang__) 538 #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
481 #define ECB_GCC_VERSION(major,minor) 0 539 #define ECB_GCC_VERSION(major,minor) 0
482 #else 540 #else
483 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) 541 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
484 #endif 542 #endif
485#endif 543#endif
544
545/*****************************************************************************/
546
547/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
548/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
549
550#if ECB_NO_THREADS
551# define ECB_NO_SMP 1
552#endif
553
554#if ECB_NO_THREADS || ECB_NO_SMP
555 #define ECB_MEMORY_FENCE do { } while (0)
556#endif
557
558#ifndef ECB_MEMORY_FENCE
559 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
560 #if __i386 || __i386__
561 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
562 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */
563 #define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */
564 #elif __amd64 || __amd64__ || __x86_64 || __x86_64__
565 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
566 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")
567 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */
568 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
569 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
570 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
571 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
572 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
573 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
574 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
575 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
576 #elif __sparc || __sparc__
577 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad | " : : : "memory")
578 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
579 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
580 #elif defined __s390__ || defined __s390x__
581 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
582 #elif defined __mips__
583 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
584 #elif defined __alpha__
585 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
586 #endif
587 #endif
588#endif
589
590#ifndef ECB_MEMORY_FENCE
591 #if ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
592 #define ECB_MEMORY_FENCE __sync_synchronize ()
593 /*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */
594 /*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */
595 #elif _MSC_VER >= 1400 /* VC++ 2005 */
596 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
597 #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
598 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
599 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
600 #elif defined _WIN32
601 #include <WinNT.h>
602 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
603 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
604 #include <mbarrier.h>
605 #define ECB_MEMORY_FENCE __machine_rw_barrier ()
606 #define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()
607 #define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()
608 #elif __xlC__
609 #define ECB_MEMORY_FENCE __sync ()
610 #endif
611#endif
612
613#ifndef ECB_MEMORY_FENCE
614 #if !ECB_AVOID_PTHREADS
615 /*
616 * if you get undefined symbol references to pthread_mutex_lock,
617 * or failure to find pthread.h, then you should implement
618 * the ECB_MEMORY_FENCE operations for your cpu/compiler
619 * OR provide pthread.h and link against the posix thread library
620 * of your system.
621 */
622 #include <pthread.h>
623 #define ECB_NEEDS_PTHREADS 1
624 #define ECB_MEMORY_FENCE_NEEDS_PTHREADS 1
625
626 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
627 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
628 #endif
629#endif
630
631#if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
632 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
633#endif
634
635#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
636 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
637#endif
638
639/*****************************************************************************/
640
641#define ECB_C99 (__STDC_VERSION__ >= 199901L)
486 642
487#if __cplusplus 643#if __cplusplus
488 #define ecb_inline static inline 644 #define ecb_inline static inline
489#elif ECB_GCC_VERSION(2,5) 645#elif ECB_GCC_VERSION(2,5)
490 #define ecb_inline static __inline__ 646 #define ecb_inline static __inline__
491#elif ECB_C99 647#elif ECB_C99
492 #define ecb_inline static inline 648 #define ecb_inline static inline
493#else 649#else
494 #define ecb_inline static 650 #define ecb_inline static
495#endif 651#endif
652
653#if ECB_GCC_VERSION(3,3)
654 #define ecb_restrict __restrict__
655#elif ECB_C99
656 #define ecb_restrict restrict
657#else
658 #define ecb_restrict
659#endif
660
661typedef int ecb_bool;
662
663#define ECB_CONCAT_(a, b) a ## b
664#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
665#define ECB_STRINGIFY_(a) # a
666#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
667
668#define ecb_function_ ecb_inline
496 669
497#if ECB_GCC_VERSION(3,1) 670#if ECB_GCC_VERSION(3,1)
498 #define ecb_attribute(attrlist) __attribute__(attrlist) 671 #define ecb_attribute(attrlist) __attribute__(attrlist)
499 #define ecb_is_constant(expr) __builtin_constant_p (expr) 672 #define ecb_is_constant(expr) __builtin_constant_p (expr)
500 #define ecb_expect(expr,value) __builtin_expect ((expr),(value)) 673 #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
504 #define ecb_is_constant(expr) 0 677 #define ecb_is_constant(expr) 0
505 #define ecb_expect(expr,value) (expr) 678 #define ecb_expect(expr,value) (expr)
506 #define ecb_prefetch(addr,rw,locality) 679 #define ecb_prefetch(addr,rw,locality)
507#endif 680#endif
508 681
682/* no emulation for ecb_decltype */
683#if ECB_GCC_VERSION(4,5)
684 #define ecb_decltype(x) __decltype(x)
685#elif ECB_GCC_VERSION(3,0)
686 #define ecb_decltype(x) __typeof(x)
687#endif
688
509#define ecb_noinline ecb_attribute ((__noinline__)) 689#define ecb_noinline ecb_attribute ((__noinline__))
510#define ecb_noreturn ecb_attribute ((__noreturn__)) 690#define ecb_noreturn ecb_attribute ((__noreturn__))
511#define ecb_unused ecb_attribute ((__unused__)) 691#define ecb_unused ecb_attribute ((__unused__))
512#define ecb_const ecb_attribute ((__const__)) 692#define ecb_const ecb_attribute ((__const__))
513#define ecb_pure ecb_attribute ((__pure__)) 693#define ecb_pure ecb_attribute ((__pure__))
525/* put around conditional expressions if you are very sure that the */ 705/* put around conditional expressions if you are very sure that the */
526/* expression is mostly true or mostly false. note that these return */ 706/* expression is mostly true or mostly false. note that these return */
527/* booleans, not the expression. */ 707/* booleans, not the expression. */
528#define ecb_expect_false(expr) ecb_expect (!!(expr), 0) 708#define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
529#define ecb_expect_true(expr) ecb_expect (!!(expr), 1) 709#define ecb_expect_true(expr) ecb_expect (!!(expr), 1)
530/* ecb.h end */ 710/* for compatibility to the rest of the world */
711#define ecb_likely(expr) ecb_expect_true (expr)
712#define ecb_unlikely(expr) ecb_expect_false (expr)
713
714/* count trailing zero bits and count # of one bits */
715#if ECB_GCC_VERSION(3,4)
716 /* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
717 #define ecb_ld32(x) (__builtin_clz (x) ^ 31)
718 #define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
719 #define ecb_ctz32(x) __builtin_ctz (x)
720 #define ecb_ctz64(x) __builtin_ctzll (x)
721 #define ecb_popcount32(x) __builtin_popcount (x)
722 /* no popcountll */
723#else
724 ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;
725 ecb_function_ int
726 ecb_ctz32 (uint32_t x)
727 {
728 int r = 0;
729
730 x &= ~x + 1; /* this isolates the lowest bit */
731
732#if ECB_branchless_on_i386
733 r += !!(x & 0xaaaaaaaa) << 0;
734 r += !!(x & 0xcccccccc) << 1;
735 r += !!(x & 0xf0f0f0f0) << 2;
736 r += !!(x & 0xff00ff00) << 3;
737 r += !!(x & 0xffff0000) << 4;
738#else
739 if (x & 0xaaaaaaaa) r += 1;
740 if (x & 0xcccccccc) r += 2;
741 if (x & 0xf0f0f0f0) r += 4;
742 if (x & 0xff00ff00) r += 8;
743 if (x & 0xffff0000) r += 16;
744#endif
745
746 return r;
747 }
748
749 ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;
750 ecb_function_ int
751 ecb_ctz64 (uint64_t x)
752 {
753 int shift = x & 0xffffffffU ? 0 : 32;
754 return ecb_ctz32 (x >> shift) + shift;
755 }
756
757 ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;
758 ecb_function_ int
759 ecb_popcount32 (uint32_t x)
760 {
761 x -= (x >> 1) & 0x55555555;
762 x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
763 x = ((x >> 4) + x) & 0x0f0f0f0f;
764 x *= 0x01010101;
765
766 return x >> 24;
767 }
768
769 ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;
770 ecb_function_ int ecb_ld32 (uint32_t x)
771 {
772 int r = 0;
773
774 if (x >> 16) { x >>= 16; r += 16; }
775 if (x >> 8) { x >>= 8; r += 8; }
776 if (x >> 4) { x >>= 4; r += 4; }
777 if (x >> 2) { x >>= 2; r += 2; }
778 if (x >> 1) { r += 1; }
779
780 return r;
781 }
782
783 ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;
784 ecb_function_ int ecb_ld64 (uint64_t x)
785 {
786 int r = 0;
787
788 if (x >> 32) { x >>= 32; r += 32; }
789
790 return r + ecb_ld32 (x);
791 }
792#endif
793
794ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;
795ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)
796{
797 return ( (x * 0x0802U & 0x22110U)
798 | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
799}
800
801ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;
802ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
803{
804 x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
805 x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
806 x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
807 x = ( x >> 8 ) | ( x << 8);
808
809 return x;
810}
811
812ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;
813ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
814{
815 x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
816 x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
817 x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
818 x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
819 x = ( x >> 16 ) | ( x << 16);
820
821 return x;
822}
823
824/* popcount64 is only available on 64 bit cpus as gcc builtin */
825/* so for this version we are lazy */
826ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
827ecb_function_ int
828ecb_popcount64 (uint64_t x)
829{
830 return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
831}
832
833ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;
834ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;
835ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;
836ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;
837ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;
838ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;
839ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;
840ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;
841
842ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
843ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
844ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
845ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
846ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
847ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
848ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
849ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
850
851#if ECB_GCC_VERSION(4,3)
852 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
853 #define ecb_bswap32(x) __builtin_bswap32 (x)
854 #define ecb_bswap64(x) __builtin_bswap64 (x)
855#else
856 ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;
857 ecb_function_ uint16_t
858 ecb_bswap16 (uint16_t x)
859 {
860 return ecb_rotl16 (x, 8);
861 }
862
863 ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;
864 ecb_function_ uint32_t
865 ecb_bswap32 (uint32_t x)
866 {
867 return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
868 }
869
870 ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;
871 ecb_function_ uint64_t
872 ecb_bswap64 (uint64_t x)
873 {
874 return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
875 }
876#endif
877
878#if ECB_GCC_VERSION(4,5)
879 #define ecb_unreachable() __builtin_unreachable ()
880#else
881 /* this seems to work fine, but gcc always emits a warning for it :/ */
882 ecb_inline void ecb_unreachable (void) ecb_noreturn;
883 ecb_inline void ecb_unreachable (void) { }
884#endif
885
886/* try to tell the compiler that some condition is definitely true */
887#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)
888
889ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
890ecb_inline unsigned char
891ecb_byteorder_helper (void)
892{
893 const uint32_t u = 0x11223344;
894 return *(unsigned char *)&u;
895}
896
897ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
898ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
899ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
900ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
901
902#if ECB_GCC_VERSION(3,0) || ECB_C99
903 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
904#else
905 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
906#endif
907
908#if __cplusplus
909 template<typename T>
910 static inline T ecb_div_rd (T val, T div)
911 {
912 return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
913 }
914 template<typename T>
915 static inline T ecb_div_ru (T val, T div)
916 {
917 return val < 0 ? - ((-val ) / div) : (val + div - 1) / div;
918 }
919#else
920 #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div))
921 #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div))
922#endif
923
924#if ecb_cplusplus_does_not_suck
925 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
926 template<typename T, int N>
927 static inline int ecb_array_length (const T (&arr)[N])
928 {
929 return N;
930 }
931#else
932 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
933#endif
934
935#endif
936
937/* ECB.H END */
938
939#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
940/* if your architecture doesn't need memory fences, e.g. because it is
941 * single-cpu/core, or if you use libev in a project that doesn't use libev
942 * from multiple threads, then you can define ECB_AVOID_PTHREADS when compiling
943 * libev, in which cases the memory fences become nops.
944 * alternatively, you can remove this #error and link against libpthread,
945 * which will then provide the memory fences.
946 */
947# error "memory fences not defined for your architecture, please report"
948#endif
949
950#ifndef ECB_MEMORY_FENCE
951# define ECB_MEMORY_FENCE do { } while (0)
952# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
953# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
954#endif
531 955
532#define expect_false(cond) ecb_expect_false (cond) 956#define expect_false(cond) ecb_expect_false (cond)
533#define expect_true(cond) ecb_expect_true (cond) 957#define expect_true(cond) ecb_expect_true (cond)
534#define noinline ecb_noinline 958#define noinline ecb_noinline
535 959
681{ 1105{
682 write (STDERR_FILENO, msg, strlen (msg)); 1106 write (STDERR_FILENO, msg, strlen (msg));
683} 1107}
684#endif 1108#endif
685 1109
686static void (*syserr_cb)(const char *msg); 1110static void (*syserr_cb)(const char *msg) EV_THROW;
687 1111
688void ecb_cold 1112void ecb_cold
689ev_set_syserr_cb (void (*cb)(const char *msg)) 1113ev_set_syserr_cb (void (*cb)(const char *msg)) EV_THROW
690{ 1114{
691 syserr_cb = cb; 1115 syserr_cb = cb;
692} 1116}
693 1117
694static void noinline ecb_cold 1118static void noinline ecb_cold
730 free (ptr); 1154 free (ptr);
731 return 0; 1155 return 0;
732#endif 1156#endif
733} 1157}
734 1158
735static void *(*alloc)(void *ptr, long size) = ev_realloc_emul; 1159static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
736 1160
737void ecb_cold 1161void ecb_cold
738ev_set_allocator (void *(*cb)(void *ptr, long size)) 1162ev_set_allocator (void *(*cb)(void *ptr, long size)) EV_THROW
739{ 1163{
740 alloc = cb; 1164 alloc = cb;
741} 1165}
742 1166
743inline_speed void * 1167inline_speed void *
831 #undef VAR 1255 #undef VAR
832 }; 1256 };
833 #include "ev_wrap.h" 1257 #include "ev_wrap.h"
834 1258
835 static struct ev_loop default_loop_struct; 1259 static struct ev_loop default_loop_struct;
836 struct ev_loop *ev_default_loop_ptr; 1260 EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
837 1261
838#else 1262#else
839 1263
840 ev_tstamp ev_rt_now; 1264 EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */
841 #define VAR(name,decl) static decl; 1265 #define VAR(name,decl) static decl;
842 #include "ev_vars.h" 1266 #include "ev_vars.h"
843 #undef VAR 1267 #undef VAR
844 1268
845 static int ev_default_loop_ptr; 1269 static int ev_default_loop_ptr;
860 1284
861/*****************************************************************************/ 1285/*****************************************************************************/
862 1286
863#ifndef EV_HAVE_EV_TIME 1287#ifndef EV_HAVE_EV_TIME
864ev_tstamp 1288ev_tstamp
865ev_time (void) 1289ev_time (void) EV_THROW
866{ 1290{
867#if EV_USE_REALTIME 1291#if EV_USE_REALTIME
868 if (expect_true (have_realtime)) 1292 if (expect_true (have_realtime))
869 { 1293 {
870 struct timespec ts; 1294 struct timespec ts;
894 return ev_time (); 1318 return ev_time ();
895} 1319}
896 1320
897#if EV_MULTIPLICITY 1321#if EV_MULTIPLICITY
898ev_tstamp 1322ev_tstamp
899ev_now (EV_P) 1323ev_now (EV_P) EV_THROW
900{ 1324{
901 return ev_rt_now; 1325 return ev_rt_now;
902} 1326}
903#endif 1327#endif
904 1328
905void 1329void
906ev_sleep (ev_tstamp delay) 1330ev_sleep (ev_tstamp delay) EV_THROW
907{ 1331{
908 if (delay > 0.) 1332 if (delay > 0.)
909 { 1333 {
910#if EV_USE_NANOSLEEP 1334#if EV_USE_NANOSLEEP
911 struct timespec ts; 1335 struct timespec ts;
912 1336
913 EV_TS_SET (ts, delay); 1337 EV_TS_SET (ts, delay);
914 nanosleep (&ts, 0); 1338 nanosleep (&ts, 0);
915#elif defined(_WIN32) 1339#elif defined _WIN32
916 Sleep ((unsigned long)(delay * 1e3)); 1340 Sleep ((unsigned long)(delay * 1e3));
917#else 1341#else
918 struct timeval tv; 1342 struct timeval tv;
919 1343
920 /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */ 1344 /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
939 1363
940 do 1364 do
941 ncur <<= 1; 1365 ncur <<= 1;
942 while (cnt > ncur); 1366 while (cnt > ncur);
943 1367
944 /* if size is large, round to MALLOC_ROUND - 4 * longs to accomodate malloc overhead */ 1368 /* if size is large, round to MALLOC_ROUND - 4 * longs to accommodate malloc overhead */
945 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4) 1369 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
946 { 1370 {
947 ncur *= elem; 1371 ncur *= elem;
948 ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1); 1372 ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
949 ncur = ncur - sizeof (void *) * 4; 1373 ncur = ncur - sizeof (void *) * 4;
964 memset ((void *)(base), 0, sizeof (*(base)) * (count)) 1388 memset ((void *)(base), 0, sizeof (*(base)) * (count))
965 1389
966#define array_needsize(type,base,cur,cnt,init) \ 1390#define array_needsize(type,base,cur,cnt,init) \
967 if (expect_false ((cnt) > (cur))) \ 1391 if (expect_false ((cnt) > (cur))) \
968 { \ 1392 { \
969 int ocur_ = (cur); \ 1393 int ecb_unused ocur_ = (cur); \
970 (base) = (type *)array_realloc \ 1394 (base) = (type *)array_realloc \
971 (sizeof (type), (base), &(cur), (cnt)); \ 1395 (sizeof (type), (base), &(cur), (cnt)); \
972 init ((base) + (ocur_), (cur) - ocur_); \ 1396 init ((base) + (ocur_), (cur) - ocur_); \
973 } 1397 }
974 1398
992pendingcb (EV_P_ ev_prepare *w, int revents) 1416pendingcb (EV_P_ ev_prepare *w, int revents)
993{ 1417{
994} 1418}
995 1419
996void noinline 1420void noinline
997ev_feed_event (EV_P_ void *w, int revents) 1421ev_feed_event (EV_P_ void *w, int revents) EV_THROW
998{ 1422{
999 W w_ = (W)w; 1423 W w_ = (W)w;
1000 int pri = ABSPRI (w_); 1424 int pri = ABSPRI (w_);
1001 1425
1002 if (expect_false (w_->pending)) 1426 if (expect_false (w_->pending))
1061 if (expect_true (!anfd->reify)) 1485 if (expect_true (!anfd->reify))
1062 fd_event_nocheck (EV_A_ fd, revents); 1486 fd_event_nocheck (EV_A_ fd, revents);
1063} 1487}
1064 1488
1065void 1489void
1066ev_feed_fd_event (EV_P_ int fd, int revents) 1490ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
1067{ 1491{
1068 if (fd >= 0 && fd < anfdmax) 1492 if (fd >= 0 && fd < anfdmax)
1069 fd_event_nocheck (EV_A_ fd, revents); 1493 fd_event_nocheck (EV_A_ fd, revents);
1070} 1494}
1071 1495
1420} 1844}
1421 1845
1422inline_speed void 1846inline_speed void
1423evpipe_write (EV_P_ EV_ATOMIC_T *flag) 1847evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1424{ 1848{
1425 if (!*flag) 1849 ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
1426 { 1850
1851 if (expect_true (*flag))
1852 return;
1853
1427 *flag = 1; 1854 *flag = 1;
1428 1855
1856 ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
1857
1429 pipe_write_skipped = 1; 1858 pipe_write_skipped = 1;
1430 1859
1860 ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
1861
1431 if (pipe_write_wanted) 1862 if (pipe_write_wanted)
1863 {
1864 int old_errno;
1865
1866 pipe_write_skipped = 0; /* just an optimisation, no fence needed */
1867
1868 old_errno = errno; /* save errno because write will clobber it */
1869
1870#if EV_USE_EVENTFD
1871 if (evfd >= 0)
1432 { 1872 {
1433 int old_errno;
1434
1435 pipe_write_skipped = 0;
1436
1437 old_errno = errno; /* save errno because write will clobber it */
1438
1439#if EV_USE_EVENTFD
1440 if (evfd >= 0)
1441 {
1442 uint64_t counter = 1; 1873 uint64_t counter = 1;
1443 write (evfd, &counter, sizeof (uint64_t)); 1874 write (evfd, &counter, sizeof (uint64_t));
1444 }
1445 else
1446#endif
1447 {
1448 /* win32 people keep sending patches that change this write() to send() */
1449 /* and then run away. but send() is wrong, it wants a socket handle on win32 */
1450 /* so when you think this write should be a send instead, please find out */
1451 /* where your send() is from - it's definitely not the microsoft send, and */
1452 /* tell me. thank you. */
1453 write (evpipe [1], &(evpipe [1]), 1);
1454 }
1455
1456 errno = old_errno;
1457 } 1875 }
1876 else
1877#endif
1878 {
1879 /* win32 people keep sending patches that change this write() to send() */
1880 /* and then run away. but send() is wrong, it wants a socket handle on win32 */
1881 /* so when you think this write should be a send instead, please find out */
1882 /* where your send() is from - it's definitely not the microsoft send, and */
1883 /* tell me. thank you. */
1884 /* it might be that your problem is that your environment needs EV_USE_WSASOCKET */
1885 /* check the ev documentation on how to use this flag */
1886 write (evpipe [1], &(evpipe [1]), 1);
1887 }
1888
1889 errno = old_errno;
1458 } 1890 }
1459} 1891}
1460 1892
1461/* called whenever the libev signal pipe */ 1893/* called whenever the libev signal pipe */
1462/* got some events (signal, async) */ 1894/* got some events (signal, async) */
1482 } 1914 }
1483 } 1915 }
1484 1916
1485 pipe_write_skipped = 0; 1917 pipe_write_skipped = 0;
1486 1918
1919 ECB_MEMORY_FENCE; /* push out skipped, acquire flags */
1920
1487#if EV_SIGNAL_ENABLE 1921#if EV_SIGNAL_ENABLE
1488 if (sig_pending) 1922 if (sig_pending)
1489 { 1923 {
1490 sig_pending = 0; 1924 sig_pending = 0;
1925
1926 ECB_MEMORY_FENCE_RELEASE;
1491 1927
1492 for (i = EV_NSIG - 1; i--; ) 1928 for (i = EV_NSIG - 1; i--; )
1493 if (expect_false (signals [i].pending)) 1929 if (expect_false (signals [i].pending))
1494 ev_feed_signal_event (EV_A_ i + 1); 1930 ev_feed_signal_event (EV_A_ i + 1);
1495 } 1931 }
1497 1933
1498#if EV_ASYNC_ENABLE 1934#if EV_ASYNC_ENABLE
1499 if (async_pending) 1935 if (async_pending)
1500 { 1936 {
1501 async_pending = 0; 1937 async_pending = 0;
1938
1939 ECB_MEMORY_FENCE_RELEASE;
1502 1940
1503 for (i = asynccnt; i--; ) 1941 for (i = asynccnt; i--; )
1504 if (asyncs [i]->sent) 1942 if (asyncs [i]->sent)
1505 { 1943 {
1506 asyncs [i]->sent = 0; 1944 asyncs [i]->sent = 0;
1511} 1949}
1512 1950
1513/*****************************************************************************/ 1951/*****************************************************************************/
1514 1952
1515void 1953void
1516ev_feed_signal (int signum) 1954ev_feed_signal (int signum) EV_THROW
1517{ 1955{
1518#if EV_MULTIPLICITY 1956#if EV_MULTIPLICITY
1519 EV_P = signals [signum - 1].loop; 1957 EV_P = signals [signum - 1].loop;
1520 1958
1521 if (!EV_A) 1959 if (!EV_A)
1522 return; 1960 return;
1523#endif 1961#endif
1524 1962
1525 evpipe_init (EV_A); 1963 if (!ev_active (&pipe_w))
1964 return;
1526 1965
1527 signals [signum - 1].pending = 1; 1966 signals [signum - 1].pending = 1;
1528 evpipe_write (EV_A_ &sig_pending); 1967 evpipe_write (EV_A_ &sig_pending);
1529} 1968}
1530 1969
1537 1976
1538 ev_feed_signal (signum); 1977 ev_feed_signal (signum);
1539} 1978}
1540 1979
1541void noinline 1980void noinline
1542ev_feed_signal_event (EV_P_ int signum) 1981ev_feed_signal_event (EV_P_ int signum) EV_THROW
1543{ 1982{
1544 WL w; 1983 WL w;
1545 1984
1546 if (expect_false (signum <= 0 || signum > EV_NSIG)) 1985 if (expect_false (signum <= 0 || signum > EV_NSIG))
1547 return; 1986 return;
1663#if EV_USE_SELECT 2102#if EV_USE_SELECT
1664# include "ev_select.c" 2103# include "ev_select.c"
1665#endif 2104#endif
1666 2105
1667int ecb_cold 2106int ecb_cold
1668ev_version_major (void) 2107ev_version_major (void) EV_THROW
1669{ 2108{
1670 return EV_VERSION_MAJOR; 2109 return EV_VERSION_MAJOR;
1671} 2110}
1672 2111
1673int ecb_cold 2112int ecb_cold
1674ev_version_minor (void) 2113ev_version_minor (void) EV_THROW
1675{ 2114{
1676 return EV_VERSION_MINOR; 2115 return EV_VERSION_MINOR;
1677} 2116}
1678 2117
1679/* return true if we are running with elevated privileges and should ignore env variables */ 2118/* return true if we are running with elevated privileges and should ignore env variables */
1687 || getgid () != getegid (); 2126 || getgid () != getegid ();
1688#endif 2127#endif
1689} 2128}
1690 2129
1691unsigned int ecb_cold 2130unsigned int ecb_cold
1692ev_supported_backends (void) 2131ev_supported_backends (void) EV_THROW
1693{ 2132{
1694 unsigned int flags = 0; 2133 unsigned int flags = 0;
1695 2134
1696 if (EV_USE_PORT ) flags |= EVBACKEND_PORT; 2135 if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
1697 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE; 2136 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
1701 2140
1702 return flags; 2141 return flags;
1703} 2142}
1704 2143
1705unsigned int ecb_cold 2144unsigned int ecb_cold
1706ev_recommended_backends (void) 2145ev_recommended_backends (void) EV_THROW
1707{ 2146{
1708 unsigned int flags = ev_supported_backends (); 2147 unsigned int flags = ev_supported_backends ();
1709 2148
1710#ifndef __NetBSD__ 2149#ifndef __NetBSD__
1711 /* kqueue is borked on everything but netbsd apparently */ 2150 /* kqueue is borked on everything but netbsd apparently */
1723 2162
1724 return flags; 2163 return flags;
1725} 2164}
1726 2165
1727unsigned int ecb_cold 2166unsigned int ecb_cold
1728ev_embeddable_backends (void) 2167ev_embeddable_backends (void) EV_THROW
1729{ 2168{
1730 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT; 2169 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
1731 2170
1732 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */ 2171 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
1733 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */ 2172 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
1735 2174
1736 return flags; 2175 return flags;
1737} 2176}
1738 2177
1739unsigned int 2178unsigned int
1740ev_backend (EV_P) 2179ev_backend (EV_P) EV_THROW
1741{ 2180{
1742 return backend; 2181 return backend;
1743} 2182}
1744 2183
1745#if EV_FEATURE_API 2184#if EV_FEATURE_API
1746unsigned int 2185unsigned int
1747ev_iteration (EV_P) 2186ev_iteration (EV_P) EV_THROW
1748{ 2187{
1749 return loop_count; 2188 return loop_count;
1750} 2189}
1751 2190
1752unsigned int 2191unsigned int
1753ev_depth (EV_P) 2192ev_depth (EV_P) EV_THROW
1754{ 2193{
1755 return loop_depth; 2194 return loop_depth;
1756} 2195}
1757 2196
1758void 2197void
1759ev_set_io_collect_interval (EV_P_ ev_tstamp interval) 2198ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
1760{ 2199{
1761 io_blocktime = interval; 2200 io_blocktime = interval;
1762} 2201}
1763 2202
1764void 2203void
1765ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) 2204ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
1766{ 2205{
1767 timeout_blocktime = interval; 2206 timeout_blocktime = interval;
1768} 2207}
1769 2208
1770void 2209void
1771ev_set_userdata (EV_P_ void *data) 2210ev_set_userdata (EV_P_ void *data) EV_THROW
1772{ 2211{
1773 userdata = data; 2212 userdata = data;
1774} 2213}
1775 2214
1776void * 2215void *
1777ev_userdata (EV_P) 2216ev_userdata (EV_P) EV_THROW
1778{ 2217{
1779 return userdata; 2218 return userdata;
1780} 2219}
1781 2220
1782void 2221void
1783ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) 2222ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
1784{ 2223{
1785 invoke_cb = invoke_pending_cb; 2224 invoke_cb = invoke_pending_cb;
1786} 2225}
1787 2226
1788void 2227void
1789ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) 2228ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW
1790{ 2229{
1791 release_cb = release; 2230 release_cb = release;
1792 acquire_cb = acquire; 2231 acquire_cb = acquire;
1793} 2232}
1794#endif 2233#endif
1795 2234
1796/* initialise a loop structure, must be zero-initialised */ 2235/* initialise a loop structure, must be zero-initialised */
1797static void noinline ecb_cold 2236static void noinline ecb_cold
1798loop_init (EV_P_ unsigned int flags) 2237loop_init (EV_P_ unsigned int flags) EV_THROW
1799{ 2238{
1800 if (!backend) 2239 if (!backend)
1801 { 2240 {
1802 origflags = flags; 2241 origflags = flags;
1803 2242
2056} 2495}
2057 2496
2058#if EV_MULTIPLICITY 2497#if EV_MULTIPLICITY
2059 2498
2060struct ev_loop * ecb_cold 2499struct ev_loop * ecb_cold
2061ev_loop_new (unsigned int flags) 2500ev_loop_new (unsigned int flags) EV_THROW
2062{ 2501{
2063 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop)); 2502 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2064 2503
2065 memset (EV_A, 0, sizeof (struct ev_loop)); 2504 memset (EV_A, 0, sizeof (struct ev_loop));
2066 loop_init (EV_A_ flags); 2505 loop_init (EV_A_ flags);
2110} 2549}
2111#endif 2550#endif
2112 2551
2113#if EV_FEATURE_API 2552#if EV_FEATURE_API
2114void ecb_cold 2553void ecb_cold
2115ev_verify (EV_P) 2554ev_verify (EV_P) EV_THROW
2116{ 2555{
2117#if EV_VERIFY 2556#if EV_VERIFY
2118 int i; 2557 int i;
2119 WL w; 2558 WL w;
2120 2559
2189#if EV_MULTIPLICITY 2628#if EV_MULTIPLICITY
2190struct ev_loop * ecb_cold 2629struct ev_loop * ecb_cold
2191#else 2630#else
2192int 2631int
2193#endif 2632#endif
2194ev_default_loop (unsigned int flags) 2633ev_default_loop (unsigned int flags) EV_THROW
2195{ 2634{
2196 if (!ev_default_loop_ptr) 2635 if (!ev_default_loop_ptr)
2197 { 2636 {
2198#if EV_MULTIPLICITY 2637#if EV_MULTIPLICITY
2199 EV_P = ev_default_loop_ptr = &default_loop_struct; 2638 EV_P = ev_default_loop_ptr = &default_loop_struct;
2218 2657
2219 return ev_default_loop_ptr; 2658 return ev_default_loop_ptr;
2220} 2659}
2221 2660
2222void 2661void
2223ev_loop_fork (EV_P) 2662ev_loop_fork (EV_P) EV_THROW
2224{ 2663{
2225 postfork = 1; /* must be in line with ev_default_fork */ 2664 postfork = 1; /* must be in line with ev_default_fork */
2226} 2665}
2227 2666
2228/*****************************************************************************/ 2667/*****************************************************************************/
2232{ 2671{
2233 EV_CB_INVOKE ((W)w, revents); 2672 EV_CB_INVOKE ((W)w, revents);
2234} 2673}
2235 2674
2236unsigned int 2675unsigned int
2237ev_pending_count (EV_P) 2676ev_pending_count (EV_P) EV_THROW
2238{ 2677{
2239 int pri; 2678 int pri;
2240 unsigned int count = 0; 2679 unsigned int count = 0;
2241 2680
2242 for (pri = NUMPRI; pri--; ) 2681 for (pri = NUMPRI; pri--; )
2501 2940
2502 mn_now = ev_rt_now; 2941 mn_now = ev_rt_now;
2503 } 2942 }
2504} 2943}
2505 2944
2506void 2945int
2507ev_run (EV_P_ int flags) 2946ev_run (EV_P_ int flags)
2508{ 2947{
2509#if EV_FEATURE_API 2948#if EV_FEATURE_API
2510 ++loop_depth; 2949 ++loop_depth;
2511#endif 2950#endif
2572 time_update (EV_A_ 1e100); 3011 time_update (EV_A_ 1e100);
2573 3012
2574 /* from now on, we want a pipe-wake-up */ 3013 /* from now on, we want a pipe-wake-up */
2575 pipe_write_wanted = 1; 3014 pipe_write_wanted = 1;
2576 3015
3016 ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3017
2577 if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped))) 3018 if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
2578 { 3019 {
2579 waittime = MAX_BLOCKTIME; 3020 waittime = MAX_BLOCKTIME;
2580 3021
2581 if (timercnt) 3022 if (timercnt)
2622#endif 3063#endif
2623 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */ 3064 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
2624 backend_poll (EV_A_ waittime); 3065 backend_poll (EV_A_ waittime);
2625 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */ 3066 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
2626 3067
2627 pipe_write_wanted = 0; 3068 pipe_write_wanted = 0; /* just an optimisation, no fence needed */
2628 3069
2629 if (pipe_write_skipped) 3070 if (pipe_write_skipped)
2630 { 3071 {
2631 assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w))); 3072 assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
2632 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM); 3073 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2666 loop_done = EVBREAK_CANCEL; 3107 loop_done = EVBREAK_CANCEL;
2667 3108
2668#if EV_FEATURE_API 3109#if EV_FEATURE_API
2669 --loop_depth; 3110 --loop_depth;
2670#endif 3111#endif
3112
3113 return activecnt;
2671} 3114}
2672 3115
2673void 3116void
2674ev_break (EV_P_ int how) 3117ev_break (EV_P_ int how) EV_THROW
2675{ 3118{
2676 loop_done = how; 3119 loop_done = how;
2677} 3120}
2678 3121
2679void 3122void
2680ev_ref (EV_P) 3123ev_ref (EV_P) EV_THROW
2681{ 3124{
2682 ++activecnt; 3125 ++activecnt;
2683} 3126}
2684 3127
2685void 3128void
2686ev_unref (EV_P) 3129ev_unref (EV_P) EV_THROW
2687{ 3130{
2688 --activecnt; 3131 --activecnt;
2689} 3132}
2690 3133
2691void 3134void
2692ev_now_update (EV_P) 3135ev_now_update (EV_P) EV_THROW
2693{ 3136{
2694 time_update (EV_A_ 1e100); 3137 time_update (EV_A_ 1e100);
2695} 3138}
2696 3139
2697void 3140void
2698ev_suspend (EV_P) 3141ev_suspend (EV_P) EV_THROW
2699{ 3142{
2700 ev_now_update (EV_A); 3143 ev_now_update (EV_A);
2701} 3144}
2702 3145
2703void 3146void
2704ev_resume (EV_P) 3147ev_resume (EV_P) EV_THROW
2705{ 3148{
2706 ev_tstamp mn_prev = mn_now; 3149 ev_tstamp mn_prev = mn_now;
2707 3150
2708 ev_now_update (EV_A); 3151 ev_now_update (EV_A);
2709 timers_reschedule (EV_A_ mn_now - mn_prev); 3152 timers_reschedule (EV_A_ mn_now - mn_prev);
2748 w->pending = 0; 3191 w->pending = 0;
2749 } 3192 }
2750} 3193}
2751 3194
2752int 3195int
2753ev_clear_pending (EV_P_ void *w) 3196ev_clear_pending (EV_P_ void *w) EV_THROW
2754{ 3197{
2755 W w_ = (W)w; 3198 W w_ = (W)w;
2756 int pending = w_->pending; 3199 int pending = w_->pending;
2757 3200
2758 if (expect_true (pending)) 3201 if (expect_true (pending))
2791} 3234}
2792 3235
2793/*****************************************************************************/ 3236/*****************************************************************************/
2794 3237
2795void noinline 3238void noinline
2796ev_io_start (EV_P_ ev_io *w) 3239ev_io_start (EV_P_ ev_io *w) EV_THROW
2797{ 3240{
2798 int fd = w->fd; 3241 int fd = w->fd;
2799 3242
2800 if (expect_false (ev_is_active (w))) 3243 if (expect_false (ev_is_active (w)))
2801 return; 3244 return;
2814 3257
2815 EV_FREQUENT_CHECK; 3258 EV_FREQUENT_CHECK;
2816} 3259}
2817 3260
2818void noinline 3261void noinline
2819ev_io_stop (EV_P_ ev_io *w) 3262ev_io_stop (EV_P_ ev_io *w) EV_THROW
2820{ 3263{
2821 clear_pending (EV_A_ (W)w); 3264 clear_pending (EV_A_ (W)w);
2822 if (expect_false (!ev_is_active (w))) 3265 if (expect_false (!ev_is_active (w)))
2823 return; 3266 return;
2824 3267
2833 3276
2834 EV_FREQUENT_CHECK; 3277 EV_FREQUENT_CHECK;
2835} 3278}
2836 3279
2837void noinline 3280void noinline
2838ev_timer_start (EV_P_ ev_timer *w) 3281ev_timer_start (EV_P_ ev_timer *w) EV_THROW
2839{ 3282{
2840 if (expect_false (ev_is_active (w))) 3283 if (expect_false (ev_is_active (w)))
2841 return; 3284 return;
2842 3285
2843 ev_at (w) += mn_now; 3286 ev_at (w) += mn_now;
2857 3300
2858 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/ 3301 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
2859} 3302}
2860 3303
2861void noinline 3304void noinline
2862ev_timer_stop (EV_P_ ev_timer *w) 3305ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
2863{ 3306{
2864 clear_pending (EV_A_ (W)w); 3307 clear_pending (EV_A_ (W)w);
2865 if (expect_false (!ev_is_active (w))) 3308 if (expect_false (!ev_is_active (w)))
2866 return; 3309 return;
2867 3310
2887 3330
2888 EV_FREQUENT_CHECK; 3331 EV_FREQUENT_CHECK;
2889} 3332}
2890 3333
2891void noinline 3334void noinline
2892ev_timer_again (EV_P_ ev_timer *w) 3335ev_timer_again (EV_P_ ev_timer *w) EV_THROW
2893{ 3336{
2894 EV_FREQUENT_CHECK; 3337 EV_FREQUENT_CHECK;
3338
3339 clear_pending (EV_A_ (W)w);
2895 3340
2896 if (ev_is_active (w)) 3341 if (ev_is_active (w))
2897 { 3342 {
2898 if (w->repeat) 3343 if (w->repeat)
2899 { 3344 {
2912 3357
2913 EV_FREQUENT_CHECK; 3358 EV_FREQUENT_CHECK;
2914} 3359}
2915 3360
2916ev_tstamp 3361ev_tstamp
2917ev_timer_remaining (EV_P_ ev_timer *w) 3362ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
2918{ 3363{
2919 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); 3364 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
2920} 3365}
2921 3366
2922#if EV_PERIODIC_ENABLE 3367#if EV_PERIODIC_ENABLE
2923void noinline 3368void noinline
2924ev_periodic_start (EV_P_ ev_periodic *w) 3369ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
2925{ 3370{
2926 if (expect_false (ev_is_active (w))) 3371 if (expect_false (ev_is_active (w)))
2927 return; 3372 return;
2928 3373
2929 if (w->reschedule_cb) 3374 if (w->reschedule_cb)
2949 3394
2950 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/ 3395 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
2951} 3396}
2952 3397
2953void noinline 3398void noinline
2954ev_periodic_stop (EV_P_ ev_periodic *w) 3399ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
2955{ 3400{
2956 clear_pending (EV_A_ (W)w); 3401 clear_pending (EV_A_ (W)w);
2957 if (expect_false (!ev_is_active (w))) 3402 if (expect_false (!ev_is_active (w)))
2958 return; 3403 return;
2959 3404
2977 3422
2978 EV_FREQUENT_CHECK; 3423 EV_FREQUENT_CHECK;
2979} 3424}
2980 3425
2981void noinline 3426void noinline
2982ev_periodic_again (EV_P_ ev_periodic *w) 3427ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
2983{ 3428{
2984 /* TODO: use adjustheap and recalculation */ 3429 /* TODO: use adjustheap and recalculation */
2985 ev_periodic_stop (EV_A_ w); 3430 ev_periodic_stop (EV_A_ w);
2986 ev_periodic_start (EV_A_ w); 3431 ev_periodic_start (EV_A_ w);
2987} 3432}
2992#endif 3437#endif
2993 3438
2994#if EV_SIGNAL_ENABLE 3439#if EV_SIGNAL_ENABLE
2995 3440
2996void noinline 3441void noinline
2997ev_signal_start (EV_P_ ev_signal *w) 3442ev_signal_start (EV_P_ ev_signal *w) EV_THROW
2998{ 3443{
2999 if (expect_false (ev_is_active (w))) 3444 if (expect_false (ev_is_active (w)))
3000 return; 3445 return;
3001 3446
3002 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG)); 3447 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
3073 3518
3074 EV_FREQUENT_CHECK; 3519 EV_FREQUENT_CHECK;
3075} 3520}
3076 3521
3077void noinline 3522void noinline
3078ev_signal_stop (EV_P_ ev_signal *w) 3523ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3079{ 3524{
3080 clear_pending (EV_A_ (W)w); 3525 clear_pending (EV_A_ (W)w);
3081 if (expect_false (!ev_is_active (w))) 3526 if (expect_false (!ev_is_active (w)))
3082 return; 3527 return;
3083 3528
3114#endif 3559#endif
3115 3560
3116#if EV_CHILD_ENABLE 3561#if EV_CHILD_ENABLE
3117 3562
3118void 3563void
3119ev_child_start (EV_P_ ev_child *w) 3564ev_child_start (EV_P_ ev_child *w) EV_THROW
3120{ 3565{
3121#if EV_MULTIPLICITY 3566#if EV_MULTIPLICITY
3122 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); 3567 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3123#endif 3568#endif
3124 if (expect_false (ev_is_active (w))) 3569 if (expect_false (ev_is_active (w)))
3131 3576
3132 EV_FREQUENT_CHECK; 3577 EV_FREQUENT_CHECK;
3133} 3578}
3134 3579
3135void 3580void
3136ev_child_stop (EV_P_ ev_child *w) 3581ev_child_stop (EV_P_ ev_child *w) EV_THROW
3137{ 3582{
3138 clear_pending (EV_A_ (W)w); 3583 clear_pending (EV_A_ (W)w);
3139 if (expect_false (!ev_is_active (w))) 3584 if (expect_false (!ev_is_active (w)))
3140 return; 3585 return;
3141 3586
3308} 3753}
3309 3754
3310inline_size int 3755inline_size int
3311infy_newfd (void) 3756infy_newfd (void)
3312{ 3757{
3313#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK) 3758#if defined IN_CLOEXEC && defined IN_NONBLOCK
3314 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK); 3759 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK);
3315 if (fd >= 0) 3760 if (fd >= 0)
3316 return fd; 3761 return fd;
3317#endif 3762#endif
3318 return inotify_init (); 3763 return inotify_init ();
3393#else 3838#else
3394# define EV_LSTAT(p,b) lstat (p, b) 3839# define EV_LSTAT(p,b) lstat (p, b)
3395#endif 3840#endif
3396 3841
3397void 3842void
3398ev_stat_stat (EV_P_ ev_stat *w) 3843ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
3399{ 3844{
3400 if (lstat (w->path, &w->attr) < 0) 3845 if (lstat (w->path, &w->attr) < 0)
3401 w->attr.st_nlink = 0; 3846 w->attr.st_nlink = 0;
3402 else if (!w->attr.st_nlink) 3847 else if (!w->attr.st_nlink)
3403 w->attr.st_nlink = 1; 3848 w->attr.st_nlink = 1;
3442 ev_feed_event (EV_A_ w, EV_STAT); 3887 ev_feed_event (EV_A_ w, EV_STAT);
3443 } 3888 }
3444} 3889}
3445 3890
3446void 3891void
3447ev_stat_start (EV_P_ ev_stat *w) 3892ev_stat_start (EV_P_ ev_stat *w) EV_THROW
3448{ 3893{
3449 if (expect_false (ev_is_active (w))) 3894 if (expect_false (ev_is_active (w)))
3450 return; 3895 return;
3451 3896
3452 ev_stat_stat (EV_A_ w); 3897 ev_stat_stat (EV_A_ w);
3473 3918
3474 EV_FREQUENT_CHECK; 3919 EV_FREQUENT_CHECK;
3475} 3920}
3476 3921
3477void 3922void
3478ev_stat_stop (EV_P_ ev_stat *w) 3923ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
3479{ 3924{
3480 clear_pending (EV_A_ (W)w); 3925 clear_pending (EV_A_ (W)w);
3481 if (expect_false (!ev_is_active (w))) 3926 if (expect_false (!ev_is_active (w)))
3482 return; 3927 return;
3483 3928
3499} 3944}
3500#endif 3945#endif
3501 3946
3502#if EV_IDLE_ENABLE 3947#if EV_IDLE_ENABLE
3503void 3948void
3504ev_idle_start (EV_P_ ev_idle *w) 3949ev_idle_start (EV_P_ ev_idle *w) EV_THROW
3505{ 3950{
3506 if (expect_false (ev_is_active (w))) 3951 if (expect_false (ev_is_active (w)))
3507 return; 3952 return;
3508 3953
3509 pri_adjust (EV_A_ (W)w); 3954 pri_adjust (EV_A_ (W)w);
3522 3967
3523 EV_FREQUENT_CHECK; 3968 EV_FREQUENT_CHECK;
3524} 3969}
3525 3970
3526void 3971void
3527ev_idle_stop (EV_P_ ev_idle *w) 3972ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
3528{ 3973{
3529 clear_pending (EV_A_ (W)w); 3974 clear_pending (EV_A_ (W)w);
3530 if (expect_false (!ev_is_active (w))) 3975 if (expect_false (!ev_is_active (w)))
3531 return; 3976 return;
3532 3977
3546} 3991}
3547#endif 3992#endif
3548 3993
3549#if EV_PREPARE_ENABLE 3994#if EV_PREPARE_ENABLE
3550void 3995void
3551ev_prepare_start (EV_P_ ev_prepare *w) 3996ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
3552{ 3997{
3553 if (expect_false (ev_is_active (w))) 3998 if (expect_false (ev_is_active (w)))
3554 return; 3999 return;
3555 4000
3556 EV_FREQUENT_CHECK; 4001 EV_FREQUENT_CHECK;
3561 4006
3562 EV_FREQUENT_CHECK; 4007 EV_FREQUENT_CHECK;
3563} 4008}
3564 4009
3565void 4010void
3566ev_prepare_stop (EV_P_ ev_prepare *w) 4011ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
3567{ 4012{
3568 clear_pending (EV_A_ (W)w); 4013 clear_pending (EV_A_ (W)w);
3569 if (expect_false (!ev_is_active (w))) 4014 if (expect_false (!ev_is_active (w)))
3570 return; 4015 return;
3571 4016
3584} 4029}
3585#endif 4030#endif
3586 4031
3587#if EV_CHECK_ENABLE 4032#if EV_CHECK_ENABLE
3588void 4033void
3589ev_check_start (EV_P_ ev_check *w) 4034ev_check_start (EV_P_ ev_check *w) EV_THROW
3590{ 4035{
3591 if (expect_false (ev_is_active (w))) 4036 if (expect_false (ev_is_active (w)))
3592 return; 4037 return;
3593 4038
3594 EV_FREQUENT_CHECK; 4039 EV_FREQUENT_CHECK;
3599 4044
3600 EV_FREQUENT_CHECK; 4045 EV_FREQUENT_CHECK;
3601} 4046}
3602 4047
3603void 4048void
3604ev_check_stop (EV_P_ ev_check *w) 4049ev_check_stop (EV_P_ ev_check *w) EV_THROW
3605{ 4050{
3606 clear_pending (EV_A_ (W)w); 4051 clear_pending (EV_A_ (W)w);
3607 if (expect_false (!ev_is_active (w))) 4052 if (expect_false (!ev_is_active (w)))
3608 return; 4053 return;
3609 4054
3622} 4067}
3623#endif 4068#endif
3624 4069
3625#if EV_EMBED_ENABLE 4070#if EV_EMBED_ENABLE
3626void noinline 4071void noinline
3627ev_embed_sweep (EV_P_ ev_embed *w) 4072ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
3628{ 4073{
3629 ev_run (w->other, EVRUN_NOWAIT); 4074 ev_run (w->other, EVRUN_NOWAIT);
3630} 4075}
3631 4076
3632static void 4077static void
3680 ev_idle_stop (EV_A_ idle); 4125 ev_idle_stop (EV_A_ idle);
3681} 4126}
3682#endif 4127#endif
3683 4128
3684void 4129void
3685ev_embed_start (EV_P_ ev_embed *w) 4130ev_embed_start (EV_P_ ev_embed *w) EV_THROW
3686{ 4131{
3687 if (expect_false (ev_is_active (w))) 4132 if (expect_false (ev_is_active (w)))
3688 return; 4133 return;
3689 4134
3690 { 4135 {
3711 4156
3712 EV_FREQUENT_CHECK; 4157 EV_FREQUENT_CHECK;
3713} 4158}
3714 4159
3715void 4160void
3716ev_embed_stop (EV_P_ ev_embed *w) 4161ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
3717{ 4162{
3718 clear_pending (EV_A_ (W)w); 4163 clear_pending (EV_A_ (W)w);
3719 if (expect_false (!ev_is_active (w))) 4164 if (expect_false (!ev_is_active (w)))
3720 return; 4165 return;
3721 4166
3731} 4176}
3732#endif 4177#endif
3733 4178
3734#if EV_FORK_ENABLE 4179#if EV_FORK_ENABLE
3735void 4180void
3736ev_fork_start (EV_P_ ev_fork *w) 4181ev_fork_start (EV_P_ ev_fork *w) EV_THROW
3737{ 4182{
3738 if (expect_false (ev_is_active (w))) 4183 if (expect_false (ev_is_active (w)))
3739 return; 4184 return;
3740 4185
3741 EV_FREQUENT_CHECK; 4186 EV_FREQUENT_CHECK;
3746 4191
3747 EV_FREQUENT_CHECK; 4192 EV_FREQUENT_CHECK;
3748} 4193}
3749 4194
3750void 4195void
3751ev_fork_stop (EV_P_ ev_fork *w) 4196ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
3752{ 4197{
3753 clear_pending (EV_A_ (W)w); 4198 clear_pending (EV_A_ (W)w);
3754 if (expect_false (!ev_is_active (w))) 4199 if (expect_false (!ev_is_active (w)))
3755 return; 4200 return;
3756 4201
3769} 4214}
3770#endif 4215#endif
3771 4216
3772#if EV_CLEANUP_ENABLE 4217#if EV_CLEANUP_ENABLE
3773void 4218void
3774ev_cleanup_start (EV_P_ ev_cleanup *w) 4219ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
3775{ 4220{
3776 if (expect_false (ev_is_active (w))) 4221 if (expect_false (ev_is_active (w)))
3777 return; 4222 return;
3778 4223
3779 EV_FREQUENT_CHECK; 4224 EV_FREQUENT_CHECK;
3786 ev_unref (EV_A); 4231 ev_unref (EV_A);
3787 EV_FREQUENT_CHECK; 4232 EV_FREQUENT_CHECK;
3788} 4233}
3789 4234
3790void 4235void
3791ev_cleanup_stop (EV_P_ ev_cleanup *w) 4236ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
3792{ 4237{
3793 clear_pending (EV_A_ (W)w); 4238 clear_pending (EV_A_ (W)w);
3794 if (expect_false (!ev_is_active (w))) 4239 if (expect_false (!ev_is_active (w)))
3795 return; 4240 return;
3796 4241
3810} 4255}
3811#endif 4256#endif
3812 4257
3813#if EV_ASYNC_ENABLE 4258#if EV_ASYNC_ENABLE
3814void 4259void
3815ev_async_start (EV_P_ ev_async *w) 4260ev_async_start (EV_P_ ev_async *w) EV_THROW
3816{ 4261{
3817 if (expect_false (ev_is_active (w))) 4262 if (expect_false (ev_is_active (w)))
3818 return; 4263 return;
3819 4264
3820 w->sent = 0; 4265 w->sent = 0;
3829 4274
3830 EV_FREQUENT_CHECK; 4275 EV_FREQUENT_CHECK;
3831} 4276}
3832 4277
3833void 4278void
3834ev_async_stop (EV_P_ ev_async *w) 4279ev_async_stop (EV_P_ ev_async *w) EV_THROW
3835{ 4280{
3836 clear_pending (EV_A_ (W)w); 4281 clear_pending (EV_A_ (W)w);
3837 if (expect_false (!ev_is_active (w))) 4282 if (expect_false (!ev_is_active (w)))
3838 return; 4283 return;
3839 4284
3850 4295
3851 EV_FREQUENT_CHECK; 4296 EV_FREQUENT_CHECK;
3852} 4297}
3853 4298
3854void 4299void
3855ev_async_send (EV_P_ ev_async *w) 4300ev_async_send (EV_P_ ev_async *w) EV_THROW
3856{ 4301{
3857 w->sent = 1; 4302 w->sent = 1;
3858 evpipe_write (EV_A_ &async_pending); 4303 evpipe_write (EV_A_ &async_pending);
3859} 4304}
3860#endif 4305#endif
3897 4342
3898 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io)); 4343 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
3899} 4344}
3900 4345
3901void 4346void
3902ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) 4347ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW
3903{ 4348{
3904 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once)); 4349 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
3905 4350
3906 if (expect_false (!once)) 4351 if (expect_false (!once))
3907 { 4352 {
3929 4374
3930/*****************************************************************************/ 4375/*****************************************************************************/
3931 4376
3932#if EV_WALK_ENABLE 4377#if EV_WALK_ENABLE
3933void ecb_cold 4378void ecb_cold
3934ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) 4379ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
3935{ 4380{
3936 int i, j; 4381 int i, j;
3937 ev_watcher_list *wl, *wn; 4382 ev_watcher_list *wl, *wn;
3938 4383
3939 if (types & (EV_IO | EV_EMBED)) 4384 if (types & (EV_IO | EV_EMBED))
3982 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i])); 4427 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
3983#endif 4428#endif
3984 4429
3985#if EV_IDLE_ENABLE 4430#if EV_IDLE_ENABLE
3986 if (types & EV_IDLE) 4431 if (types & EV_IDLE)
3987 for (j = NUMPRI; i--; ) 4432 for (j = NUMPRI; j--; )
3988 for (i = idlecnt [j]; i--; ) 4433 for (i = idlecnt [j]; i--; )
3989 cb (EV_A_ EV_IDLE, idles [j][i]); 4434 cb (EV_A_ EV_IDLE, idles [j][i]);
3990#endif 4435#endif
3991 4436
3992#if EV_FORK_ENABLE 4437#if EV_FORK_ENABLE
4045 4490
4046#if EV_MULTIPLICITY 4491#if EV_MULTIPLICITY
4047 #include "ev_wrap.h" 4492 #include "ev_wrap.h"
4048#endif 4493#endif
4049 4494
4050EV_CPP(})
4051

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines