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

Comparing libev/ev.c (file contents):
Revision 1.395 by root, Wed Aug 24 16:08:17 2011 UTC vs.
Revision 1.421 by root, Wed Apr 18 06:06:04 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
… …
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
… …
469/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */ 478/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
470/* ECB.H BEGIN */ 479/* ECB.H BEGIN */
471/* 480/*
472 * libecb - http://software.schmorp.de/pkg/libecb 481 * libecb - http://software.schmorp.de/pkg/libecb
473 * 482 *
474 * Copyright (©) 2009-2011 Marc Alexander Lehmann <libecb@schmorp.de> 483 * Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>
475 * Copyright (©) 2011 Emanuele Giaquinta 484 * Copyright (©) 2011 Emanuele Giaquinta
476 * All rights reserved. 485 * All rights reserved.
477 * 486 *
478 * Redistribution and use in source and binary forms, with or without modifica- 487 * Redistribution and use in source and binary forms, with or without modifica-
479 * tion, are permitted provided that the following conditions are met: 488 * tion, are permitted provided that the following conditions are met:
… …
524 * or so. 533 * or so.
525 * 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
526 * 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.
527 */ 536 */
528#ifndef ECB_GCC_VERSION 537#ifndef ECB_GCC_VERSION
529 #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__
530 #define ECB_GCC_VERSION(major,minor) 0 539 #define ECB_GCC_VERSION(major,minor) 0
531 #else 540 #else
532 #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)))
533 #endif 542 #endif
534#endif 543#endif
… …
536/*****************************************************************************/ 545/*****************************************************************************/
537 546
538/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */ 547/* 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 */ 548/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
540 549
550#if ECB_NO_THREADS
551# define ECB_NO_SMP 1
552#endif
553
541#if ECB_NO_THREADS || ECB_NO_SMP 554#if ECB_NO_THREADS || ECB_NO_SMP
542 #define ECB_MEMORY_FENCE do { } while (0) 555 #define ECB_MEMORY_FENCE do { } while (0)
543#endif 556#endif
544 557
545#ifndef ECB_MEMORY_FENCE 558#ifndef ECB_MEMORY_FENCE
546 #if ECB_GCC_VERSION(2,5) 559 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
547 #if __i386__ 560 #if __i386 || __i386__
548 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory") 561 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
549 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */ 562 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */
550 #define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */ 563 #define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */
551 #elif __amd64 564 #elif __amd64 || __amd64__ || __x86_64 || __x86_64__
552 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory") 565 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
553 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory") 566 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")
554 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */ 567 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */
555 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ 568 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
556 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 569 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
557 #elif defined(__ARM_ARCH_6__ ) || defined(__ARM_ARCH_6J__ ) \ 570 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
558 || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__) 571 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
559 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory") 572 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
560 #elif defined(__ARM_ARCH_7__ ) || defined(__ARM_ARCH_7A__ ) \ 573 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
561 || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7R__ ) 574 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
562 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory") 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")
563 #endif 586 #endif
564 #endif 587 #endif
565#endif 588#endif
566 589
567#ifndef ECB_MEMORY_FENCE 590#ifndef ECB_MEMORY_FENCE
568 #if ECB_GCC_VERSION(4,4) || defined(__INTEL_COMPILER) 591 #if ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
569 #define ECB_MEMORY_FENCE __sync_synchronize () 592 #define ECB_MEMORY_FENCE __sync_synchronize ()
570 /*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */ 593 /*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */
571 /*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */ 594 /*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */
572 #elif _MSC_VER >= 1400 /* VC++ 2005 */ 595 #elif _MSC_VER >= 1400 /* VC++ 2005 */
573 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier) 596 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
574 #define ECB_MEMORY_FENCE _ReadWriteBarrier () 597 #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
575 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */ 598 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
576 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier () 599 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
577 #elif defined(_WIN32) 600 #elif defined _WIN32
578 #include <WinNT.h> 601 #include <WinNT.h>
579 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */ 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 ()
580 #endif 610 #endif
581#endif 611#endif
582 612
583#ifndef ECB_MEMORY_FENCE 613#ifndef ECB_MEMORY_FENCE
584 #if !ECB_AVOID_PTHREADS 614 #if !ECB_AVOID_PTHREADS
… …
596 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER; 626 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
597 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0) 627 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
598 #endif 628 #endif
599#endif 629#endif
600 630
601#if !defined(ECB_MEMORY_FENCE_ACQUIRE) && defined(ECB_MEMORY_FENCE) 631#if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
602 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE 632 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
603#endif 633#endif
604 634
605#if !defined(ECB_MEMORY_FENCE_RELEASE) && defined(ECB_MEMORY_FENCE) 635#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
606 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE 636 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
607#endif 637#endif
608 638
609/*****************************************************************************/ 639/*****************************************************************************/
610 640
… …
759 789
760 return r + ecb_ld32 (x); 790 return r + ecb_ld32 (x);
761 } 791 }
762#endif 792#endif
763 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
764/* popcount64 is only available on 64 bit cpus as gcc builtin */ 824/* popcount64 is only available on 64 bit cpus as gcc builtin */
765/* so for this version we are lazy */ 825/* so for this version we are lazy */
766ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const; 826ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
767ecb_function_ int 827ecb_function_ int
768ecb_popcount64 (uint64_t x) 828ecb_popcount64 (uint64_t x)
… …
817 877
818#if ECB_GCC_VERSION(4,5) 878#if ECB_GCC_VERSION(4,5)
819 #define ecb_unreachable() __builtin_unreachable () 879 #define ecb_unreachable() __builtin_unreachable ()
820#else 880#else
821 /* this seems to work fine, but gcc always emits a warning for it :/ */ 881 /* this seems to work fine, but gcc always emits a warning for it :/ */
822 ecb_function_ void ecb_unreachable (void) ecb_noreturn; 882 ecb_inline void ecb_unreachable (void) ecb_noreturn;
823 ecb_function_ void ecb_unreachable (void) { } 883 ecb_inline void ecb_unreachable (void) { }
824#endif 884#endif
825 885
826/* try to tell the compiler that some condition is definitely true */ 886/* try to tell the compiler that some condition is definitely true */
827#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0) 887#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)
828 888
829ecb_function_ unsigned char ecb_byteorder_helper (void) ecb_const; 889ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
830ecb_function_ unsigned char 890ecb_inline unsigned char
831ecb_byteorder_helper (void) 891ecb_byteorder_helper (void)
832{ 892{
833 const uint32_t u = 0x11223344; 893 const uint32_t u = 0x11223344;
834 return *(unsigned char *)&u; 894 return *(unsigned char *)&u;
835} 895}
836 896
837ecb_function_ ecb_bool ecb_big_endian (void) ecb_const; 897ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
838ecb_function_ ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; } 898ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
839ecb_function_ ecb_bool ecb_little_endian (void) ecb_const; 899ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
840ecb_function_ ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; } 900ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
841 901
842#if ECB_GCC_VERSION(3,0) || ECB_C99 902#if ECB_GCC_VERSION(3,0) || ECB_C99
843 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0)) 903 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
844#else 904#else
845 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n))) 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))
846#endif 922#endif
847 923
848#if ecb_cplusplus_does_not_suck 924#if ecb_cplusplus_does_not_suck
849 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */ 925 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
850 template<typename T, int N> 926 template<typename T, int N>
… …
859#endif 935#endif
860 936
861/* ECB.H END */ 937/* ECB.H END */
862 938
863#if ECB_MEMORY_FENCE_NEEDS_PTHREADS 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
864# undef ECB_MEMORY_FENCE 950#ifndef ECB_MEMORY_FENCE
865# undef ECB_MEMORY_FENCE_ACQUIRE 951# define ECB_MEMORY_FENCE do { } while (0)
866# undef ECB_MEMORY_FENCE_RELEASE 952# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
953# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
867#endif 954#endif
868 955
869#define expect_false(cond) ecb_expect_false (cond) 956#define expect_false(cond) ecb_expect_false (cond)
870#define expect_true(cond) ecb_expect_true (cond) 957#define expect_true(cond) ecb_expect_true (cond)
871#define noinline ecb_noinline 958#define noinline ecb_noinline
… …
1018{ 1105{
1019 write (STDERR_FILENO, msg, strlen (msg)); 1106 write (STDERR_FILENO, msg, strlen (msg));
1020} 1107}
1021#endif 1108#endif
1022 1109
1023static void (*syserr_cb)(const char *msg); 1110static void (*syserr_cb)(const char *msg) EV_THROW;
1024 1111
1025void ecb_cold 1112void ecb_cold
1026ev_set_syserr_cb (void (*cb)(const char *msg)) 1113ev_set_syserr_cb (void (*cb)(const char *msg)) EV_THROW
1027{ 1114{
1028 syserr_cb = cb; 1115 syserr_cb = cb;
1029} 1116}
1030 1117
1031static void noinline ecb_cold 1118static void noinline ecb_cold
… …
1067 free (ptr); 1154 free (ptr);
1068 return 0; 1155 return 0;
1069#endif 1156#endif
1070} 1157}
1071 1158
1072static void *(*alloc)(void *ptr, long size) = ev_realloc_emul; 1159static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1073 1160
1074void ecb_cold 1161void ecb_cold
1075ev_set_allocator (void *(*cb)(void *ptr, long size)) 1162ev_set_allocator (void *(*cb)(void *ptr, long size)) EV_THROW
1076{ 1163{
1077 alloc = cb; 1164 alloc = cb;
1078} 1165}
1079 1166
1080inline_speed void * 1167inline_speed void *
… …
1168 #undef VAR 1255 #undef VAR
1169 }; 1256 };
1170 #include "ev_wrap.h" 1257 #include "ev_wrap.h"
1171 1258
1172 static struct ev_loop default_loop_struct; 1259 static struct ev_loop default_loop_struct;
1173 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 */
1174 1261
1175#else 1262#else
1176 1263
1177 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 */
1178 #define VAR(name,decl) static decl; 1265 #define VAR(name,decl) static decl;
1179 #include "ev_vars.h" 1266 #include "ev_vars.h"
1180 #undef VAR 1267 #undef VAR
1181 1268
1182 static int ev_default_loop_ptr; 1269 static int ev_default_loop_ptr;
… …
1197 1284
1198/*****************************************************************************/ 1285/*****************************************************************************/
1199 1286
1200#ifndef EV_HAVE_EV_TIME 1287#ifndef EV_HAVE_EV_TIME
1201ev_tstamp 1288ev_tstamp
1202ev_time (void) 1289ev_time (void) EV_THROW
1203{ 1290{
1204#if EV_USE_REALTIME 1291#if EV_USE_REALTIME
1205 if (expect_true (have_realtime)) 1292 if (expect_true (have_realtime))
1206 { 1293 {
1207 struct timespec ts; 1294 struct timespec ts;
… …
1231 return ev_time (); 1318 return ev_time ();
1232} 1319}
1233 1320
1234#if EV_MULTIPLICITY 1321#if EV_MULTIPLICITY
1235ev_tstamp 1322ev_tstamp
1236ev_now (EV_P) 1323ev_now (EV_P) EV_THROW
1237{ 1324{
1238 return ev_rt_now; 1325 return ev_rt_now;
1239} 1326}
1240#endif 1327#endif
1241 1328
1242void 1329void
1243ev_sleep (ev_tstamp delay) 1330ev_sleep (ev_tstamp delay) EV_THROW
1244{ 1331{
1245 if (delay > 0.) 1332 if (delay > 0.)
1246 { 1333 {
1247#if EV_USE_NANOSLEEP 1334#if EV_USE_NANOSLEEP
1248 struct timespec ts; 1335 struct timespec ts;
1249 1336
1250 EV_TS_SET (ts, delay); 1337 EV_TS_SET (ts, delay);
1251 nanosleep (&ts, 0); 1338 nanosleep (&ts, 0);
1252#elif defined(_WIN32) 1339#elif defined _WIN32
1253 Sleep ((unsigned long)(delay * 1e3)); 1340 Sleep ((unsigned long)(delay * 1e3));
1254#else 1341#else
1255 struct timeval tv; 1342 struct timeval tv;
1256 1343
1257 /* 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 */
… …
1276 1363
1277 do 1364 do
1278 ncur <<= 1; 1365 ncur <<= 1;
1279 while (cnt > ncur); 1366 while (cnt > ncur);
1280 1367
1281 /* 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 */
1282 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4) 1369 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
1283 { 1370 {
1284 ncur *= elem; 1371 ncur *= elem;
1285 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);
1286 ncur = ncur - sizeof (void *) * 4; 1373 ncur = ncur - sizeof (void *) * 4;
… …
1329pendingcb (EV_P_ ev_prepare *w, int revents) 1416pendingcb (EV_P_ ev_prepare *w, int revents)
1330{ 1417{
1331} 1418}
1332 1419
1333void noinline 1420void noinline
1334ev_feed_event (EV_P_ void *w, int revents) 1421ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1335{ 1422{
1336 W w_ = (W)w; 1423 W w_ = (W)w;
1337 int pri = ABSPRI (w_); 1424 int pri = ABSPRI (w_);
1338 1425
1339 if (expect_false (w_->pending)) 1426 if (expect_false (w_->pending))
… …
1398 if (expect_true (!anfd->reify)) 1485 if (expect_true (!anfd->reify))
1399 fd_event_nocheck (EV_A_ fd, revents); 1486 fd_event_nocheck (EV_A_ fd, revents);
1400} 1487}
1401 1488
1402void 1489void
1403ev_feed_fd_event (EV_P_ int fd, int revents) 1490ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
1404{ 1491{
1405 if (fd >= 0 && fd < anfdmax) 1492 if (fd >= 0 && fd < anfdmax)
1406 fd_event_nocheck (EV_A_ fd, revents); 1493 fd_event_nocheck (EV_A_ fd, revents);
1407} 1494}
1408 1495
… …
1790 /* win32 people keep sending patches that change this write() to send() */ 1877 /* win32 people keep sending patches that change this write() to send() */
1791 /* and then run away. but send() is wrong, it wants a socket handle on win32 */ 1878 /* and then run away. but send() is wrong, it wants a socket handle on win32 */
1792 /* so when you think this write should be a send instead, please find out */ 1879 /* so when you think this write should be a send instead, please find out */
1793 /* where your send() is from - it's definitely not the microsoft send, and */ 1880 /* where your send() is from - it's definitely not the microsoft send, and */
1794 /* tell me. thank you. */ 1881 /* tell me. thank you. */
1882 /* it might be that your problem is that your environment needs EV_USE_WSASOCKET */
1883 /* check the ev documentation on how to use this flag */
1795 write (evpipe [1], &(evpipe [1]), 1); 1884 write (evpipe [1], &(evpipe [1]), 1);
1796 } 1885 }
1797 1886
1798 errno = old_errno; 1887 errno = old_errno;
1799 } 1888 }
… …
1852} 1941}
1853 1942
1854/*****************************************************************************/ 1943/*****************************************************************************/
1855 1944
1856void 1945void
1857ev_feed_signal (int signum) 1946ev_feed_signal (int signum) EV_THROW
1858{ 1947{
1859#if EV_MULTIPLICITY 1948#if EV_MULTIPLICITY
1860 EV_P = signals [signum - 1].loop; 1949 EV_P = signals [signum - 1].loop;
1861 1950
1862 if (!EV_A) 1951 if (!EV_A)
… …
1879 1968
1880 ev_feed_signal (signum); 1969 ev_feed_signal (signum);
1881} 1970}
1882 1971
1883void noinline 1972void noinline
1884ev_feed_signal_event (EV_P_ int signum) 1973ev_feed_signal_event (EV_P_ int signum) EV_THROW
1885{ 1974{
1886 WL w; 1975 WL w;
1887 1976
1888 if (expect_false (signum <= 0 || signum > EV_NSIG)) 1977 if (expect_false (signum <= 0 || signum > EV_NSIG))
1889 return; 1978 return;
… …
2005#if EV_USE_SELECT 2094#if EV_USE_SELECT
2006# include "ev_select.c" 2095# include "ev_select.c"
2007#endif 2096#endif
2008 2097
2009int ecb_cold 2098int ecb_cold
2010ev_version_major (void) 2099ev_version_major (void) EV_THROW
2011{ 2100{
2012 return EV_VERSION_MAJOR; 2101 return EV_VERSION_MAJOR;
2013} 2102}
2014 2103
2015int ecb_cold 2104int ecb_cold
2016ev_version_minor (void) 2105ev_version_minor (void) EV_THROW
2017{ 2106{
2018 return EV_VERSION_MINOR; 2107 return EV_VERSION_MINOR;
2019} 2108}
2020 2109
2021/* return true if we are running with elevated privileges and should ignore env variables */ 2110/* return true if we are running with elevated privileges and should ignore env variables */
… …
2029 || getgid () != getegid (); 2118 || getgid () != getegid ();
2030#endif 2119#endif
2031} 2120}
2032 2121
2033unsigned int ecb_cold 2122unsigned int ecb_cold
2034ev_supported_backends (void) 2123ev_supported_backends (void) EV_THROW
2035{ 2124{
2036 unsigned int flags = 0; 2125 unsigned int flags = 0;
2037 2126
2038 if (EV_USE_PORT ) flags |= EVBACKEND_PORT; 2127 if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2039 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE; 2128 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
… …
2043 2132
2044 return flags; 2133 return flags;
2045} 2134}
2046 2135
2047unsigned int ecb_cold 2136unsigned int ecb_cold
2048ev_recommended_backends (void) 2137ev_recommended_backends (void) EV_THROW
2049{ 2138{
2050 unsigned int flags = ev_supported_backends (); 2139 unsigned int flags = ev_supported_backends ();
2051 2140
2052#ifndef __NetBSD__ 2141#ifndef __NetBSD__
2053 /* kqueue is borked on everything but netbsd apparently */ 2142 /* kqueue is borked on everything but netbsd apparently */
… …
2065 2154
2066 return flags; 2155 return flags;
2067} 2156}
2068 2157
2069unsigned int ecb_cold 2158unsigned int ecb_cold
2070ev_embeddable_backends (void) 2159ev_embeddable_backends (void) EV_THROW
2071{ 2160{
2072 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT; 2161 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2073 2162
2074 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */ 2163 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2075 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */ 2164 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
… …
2077 2166
2078 return flags; 2167 return flags;
2079} 2168}
2080 2169
2081unsigned int 2170unsigned int
2082ev_backend (EV_P) 2171ev_backend (EV_P) EV_THROW
2083{ 2172{
2084 return backend; 2173 return backend;
2085} 2174}
2086 2175
2087#if EV_FEATURE_API 2176#if EV_FEATURE_API
2088unsigned int 2177unsigned int
2089ev_iteration (EV_P) 2178ev_iteration (EV_P) EV_THROW
2090{ 2179{
2091 return loop_count; 2180 return loop_count;
2092} 2181}
2093 2182
2094unsigned int 2183unsigned int
2095ev_depth (EV_P) 2184ev_depth (EV_P) EV_THROW
2096{ 2185{
2097 return loop_depth; 2186 return loop_depth;
2098} 2187}
2099 2188
2100void 2189void
2101ev_set_io_collect_interval (EV_P_ ev_tstamp interval) 2190ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2102{ 2191{
2103 io_blocktime = interval; 2192 io_blocktime = interval;
2104} 2193}
2105 2194
2106void 2195void
2107ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) 2196ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2108{ 2197{
2109 timeout_blocktime = interval; 2198 timeout_blocktime = interval;
2110} 2199}
2111 2200
2112void 2201void
2113ev_set_userdata (EV_P_ void *data) 2202ev_set_userdata (EV_P_ void *data) EV_THROW
2114{ 2203{
2115 userdata = data; 2204 userdata = data;
2116} 2205}
2117 2206
2118void * 2207void *
2119ev_userdata (EV_P) 2208ev_userdata (EV_P) EV_THROW
2120{ 2209{
2121 return userdata; 2210 return userdata;
2122} 2211}
2123 2212
2124void 2213void
2125ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) 2214ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
2126{ 2215{
2127 invoke_cb = invoke_pending_cb; 2216 invoke_cb = invoke_pending_cb;
2128} 2217}
2129 2218
2130void 2219void
2131ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) 2220ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW
2132{ 2221{
2133 release_cb = release; 2222 release_cb = release;
2134 acquire_cb = acquire; 2223 acquire_cb = acquire;
2135} 2224}
2136#endif 2225#endif
2137 2226
2138/* initialise a loop structure, must be zero-initialised */ 2227/* initialise a loop structure, must be zero-initialised */
2139static void noinline ecb_cold 2228static void noinline ecb_cold
2140loop_init (EV_P_ unsigned int flags) 2229loop_init (EV_P_ unsigned int flags) EV_THROW
2141{ 2230{
2142 if (!backend) 2231 if (!backend)
2143 { 2232 {
2144 origflags = flags; 2233 origflags = flags;
2145 2234
… …
2230 } 2319 }
2231} 2320}
2232 2321
2233/* free up a loop structure */ 2322/* free up a loop structure */
2234void ecb_cold 2323void ecb_cold
2235ev_loop_destroy (EV_P) 2324ev_loop_destroy (EV_P) EV_THROW
2236{ 2325{
2237 int i; 2326 int i;
2238 2327
2239#if EV_MULTIPLICITY 2328#if EV_MULTIPLICITY
2240 /* mimic free (0) */ 2329 /* mimic free (0) */
… …
2398} 2487}
2399 2488
2400#if EV_MULTIPLICITY 2489#if EV_MULTIPLICITY
2401 2490
2402struct ev_loop * ecb_cold 2491struct ev_loop * ecb_cold
2403ev_loop_new (unsigned int flags) 2492ev_loop_new (unsigned int flags) EV_THROW
2404{ 2493{
2405 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop)); 2494 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2406 2495
2407 memset (EV_A, 0, sizeof (struct ev_loop)); 2496 memset (EV_A, 0, sizeof (struct ev_loop));
2408 loop_init (EV_A_ flags); 2497 loop_init (EV_A_ flags);
… …
2452} 2541}
2453#endif 2542#endif
2454 2543
2455#if EV_FEATURE_API 2544#if EV_FEATURE_API
2456void ecb_cold 2545void ecb_cold
2457ev_verify (EV_P) 2546ev_verify (EV_P) EV_THROW
2458{ 2547{
2459#if EV_VERIFY 2548#if EV_VERIFY
2460 int i; 2549 int i;
2461 WL w; 2550 WL w;
2462 2551
… …
2531#if EV_MULTIPLICITY 2620#if EV_MULTIPLICITY
2532struct ev_loop * ecb_cold 2621struct ev_loop * ecb_cold
2533#else 2622#else
2534int 2623int
2535#endif 2624#endif
2536ev_default_loop (unsigned int flags) 2625ev_default_loop (unsigned int flags) EV_THROW
2537{ 2626{
2538 if (!ev_default_loop_ptr) 2627 if (!ev_default_loop_ptr)
2539 { 2628 {
2540#if EV_MULTIPLICITY 2629#if EV_MULTIPLICITY
2541 EV_P = ev_default_loop_ptr = &default_loop_struct; 2630 EV_P = ev_default_loop_ptr = &default_loop_struct;
… …
2560 2649
2561 return ev_default_loop_ptr; 2650 return ev_default_loop_ptr;
2562} 2651}
2563 2652
2564void 2653void
2565ev_loop_fork (EV_P) 2654ev_loop_fork (EV_P) EV_THROW
2566{ 2655{
2567 postfork = 1; /* must be in line with ev_default_fork */ 2656 postfork = 1; /* must be in line with ev_default_fork */
2568} 2657}
2569 2658
2570/*****************************************************************************/ 2659/*****************************************************************************/
… …
2574{ 2663{
2575 EV_CB_INVOKE ((W)w, revents); 2664 EV_CB_INVOKE ((W)w, revents);
2576} 2665}
2577 2666
2578unsigned int 2667unsigned int
2579ev_pending_count (EV_P) 2668ev_pending_count (EV_P) EV_THROW
2580{ 2669{
2581 int pri; 2670 int pri;
2582 unsigned int count = 0; 2671 unsigned int count = 0;
2583 2672
2584 for (pri = NUMPRI; pri--; ) 2673 for (pri = NUMPRI; pri--; )
… …
2843 2932
2844 mn_now = ev_rt_now; 2933 mn_now = ev_rt_now;
2845 } 2934 }
2846} 2935}
2847 2936
2848void 2937int
2849ev_run (EV_P_ int flags) 2938ev_run (EV_P_ int flags)
2850{ 2939{
2851#if EV_FEATURE_API 2940#if EV_FEATURE_API
2852 ++loop_depth; 2941 ++loop_depth;
2853#endif 2942#endif
… …
2966#endif 3055#endif
2967 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */ 3056 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
2968 backend_poll (EV_A_ waittime); 3057 backend_poll (EV_A_ waittime);
2969 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */ 3058 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
2970 3059
2971 pipe_write_wanted = 0; /* just an optimsiation, no fence needed */ 3060 pipe_write_wanted = 0; /* just an optimisation, no fence needed */
2972 3061
2973 if (pipe_write_skipped) 3062 if (pipe_write_skipped)
2974 { 3063 {
2975 assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w))); 3064 assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
2976 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM); 3065 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
… …
3010 loop_done = EVBREAK_CANCEL; 3099 loop_done = EVBREAK_CANCEL;
3011 3100
3012#if EV_FEATURE_API 3101#if EV_FEATURE_API
3013 --loop_depth; 3102 --loop_depth;
3014#endif 3103#endif
3104
3105 return activecnt;
3015} 3106}
3016 3107
3017void 3108void
3018ev_break (EV_P_ int how) 3109ev_break (EV_P_ int how) EV_THROW
3019{ 3110{
3020 loop_done = how; 3111 loop_done = how;
3021} 3112}
3022 3113
3023void 3114void
3024ev_ref (EV_P) 3115ev_ref (EV_P) EV_THROW
3025{ 3116{
3026 ++activecnt; 3117 ++activecnt;
3027} 3118}
3028 3119
3029void 3120void
3030ev_unref (EV_P) 3121ev_unref (EV_P) EV_THROW
3031{ 3122{
3032 --activecnt; 3123 --activecnt;
3033} 3124}
3034 3125
3035void 3126void
3036ev_now_update (EV_P) 3127ev_now_update (EV_P) EV_THROW
3037{ 3128{
3038 time_update (EV_A_ 1e100); 3129 time_update (EV_A_ 1e100);
3039} 3130}
3040 3131
3041void 3132void
3042ev_suspend (EV_P) 3133ev_suspend (EV_P) EV_THROW
3043{ 3134{
3044 ev_now_update (EV_A); 3135 ev_now_update (EV_A);
3045} 3136}
3046 3137
3047void 3138void
3048ev_resume (EV_P) 3139ev_resume (EV_P) EV_THROW
3049{ 3140{
3050 ev_tstamp mn_prev = mn_now; 3141 ev_tstamp mn_prev = mn_now;
3051 3142
3052 ev_now_update (EV_A); 3143 ev_now_update (EV_A);
3053 timers_reschedule (EV_A_ mn_now - mn_prev); 3144 timers_reschedule (EV_A_ mn_now - mn_prev);
… …
3092 w->pending = 0; 3183 w->pending = 0;
3093 } 3184 }
3094} 3185}
3095 3186
3096int 3187int
3097ev_clear_pending (EV_P_ void *w) 3188ev_clear_pending (EV_P_ void *w) EV_THROW
3098{ 3189{
3099 W w_ = (W)w; 3190 W w_ = (W)w;
3100 int pending = w_->pending; 3191 int pending = w_->pending;
3101 3192
3102 if (expect_true (pending)) 3193 if (expect_true (pending))
… …
3135} 3226}
3136 3227
3137/*****************************************************************************/ 3228/*****************************************************************************/
3138 3229
3139void noinline 3230void noinline
3140ev_io_start (EV_P_ ev_io *w) 3231ev_io_start (EV_P_ ev_io *w) EV_THROW
3141{ 3232{
3142 int fd = w->fd; 3233 int fd = w->fd;
3143 3234
3144 if (expect_false (ev_is_active (w))) 3235 if (expect_false (ev_is_active (w)))
3145 return; 3236 return;
… …
3158 3249
3159 EV_FREQUENT_CHECK; 3250 EV_FREQUENT_CHECK;
3160} 3251}
3161 3252
3162void noinline 3253void noinline
3163ev_io_stop (EV_P_ ev_io *w) 3254ev_io_stop (EV_P_ ev_io *w) EV_THROW
3164{ 3255{
3165 clear_pending (EV_A_ (W)w); 3256 clear_pending (EV_A_ (W)w);
3166 if (expect_false (!ev_is_active (w))) 3257 if (expect_false (!ev_is_active (w)))
3167 return; 3258 return;
3168 3259
… …
3177 3268
3178 EV_FREQUENT_CHECK; 3269 EV_FREQUENT_CHECK;
3179} 3270}
3180 3271
3181void noinline 3272void noinline
3182ev_timer_start (EV_P_ ev_timer *w) 3273ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3183{ 3274{
3184 if (expect_false (ev_is_active (w))) 3275 if (expect_false (ev_is_active (w)))
3185 return; 3276 return;
3186 3277
3187 ev_at (w) += mn_now; 3278 ev_at (w) += mn_now;
… …
3201 3292
3202 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/ 3293 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3203} 3294}
3204 3295
3205void noinline 3296void noinline
3206ev_timer_stop (EV_P_ ev_timer *w) 3297ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3207{ 3298{
3208 clear_pending (EV_A_ (W)w); 3299 clear_pending (EV_A_ (W)w);
3209 if (expect_false (!ev_is_active (w))) 3300 if (expect_false (!ev_is_active (w)))
3210 return; 3301 return;
3211 3302
… …
3231 3322
3232 EV_FREQUENT_CHECK; 3323 EV_FREQUENT_CHECK;
3233} 3324}
3234 3325
3235void noinline 3326void noinline
3236ev_timer_again (EV_P_ ev_timer *w) 3327ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3237{ 3328{
3238 EV_FREQUENT_CHECK; 3329 EV_FREQUENT_CHECK;
3330
3331 clear_pending (EV_A_ (W)w);
3239 3332
3240 if (ev_is_active (w)) 3333 if (ev_is_active (w))
3241 { 3334 {
3242 if (w->repeat) 3335 if (w->repeat)
3243 { 3336 {
… …
3256 3349
3257 EV_FREQUENT_CHECK; 3350 EV_FREQUENT_CHECK;
3258} 3351}
3259 3352
3260ev_tstamp 3353ev_tstamp
3261ev_timer_remaining (EV_P_ ev_timer *w) 3354ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
3262{ 3355{
3263 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); 3356 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3264} 3357}
3265 3358
3266#if EV_PERIODIC_ENABLE 3359#if EV_PERIODIC_ENABLE
3267void noinline 3360void noinline
3268ev_periodic_start (EV_P_ ev_periodic *w) 3361ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3269{ 3362{
3270 if (expect_false (ev_is_active (w))) 3363 if (expect_false (ev_is_active (w)))
3271 return; 3364 return;
3272 3365
3273 if (w->reschedule_cb) 3366 if (w->reschedule_cb)
… …
3293 3386
3294 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/ 3387 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3295} 3388}
3296 3389
3297void noinline 3390void noinline
3298ev_periodic_stop (EV_P_ ev_periodic *w) 3391ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3299{ 3392{
3300 clear_pending (EV_A_ (W)w); 3393 clear_pending (EV_A_ (W)w);
3301 if (expect_false (!ev_is_active (w))) 3394 if (expect_false (!ev_is_active (w)))
3302 return; 3395 return;
3303 3396
… …
3321 3414
3322 EV_FREQUENT_CHECK; 3415 EV_FREQUENT_CHECK;
3323} 3416}
3324 3417
3325void noinline 3418void noinline
3326ev_periodic_again (EV_P_ ev_periodic *w) 3419ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3327{ 3420{
3328 /* TODO: use adjustheap and recalculation */ 3421 /* TODO: use adjustheap and recalculation */
3329 ev_periodic_stop (EV_A_ w); 3422 ev_periodic_stop (EV_A_ w);
3330 ev_periodic_start (EV_A_ w); 3423 ev_periodic_start (EV_A_ w);
3331} 3424}
… …
3336#endif 3429#endif
3337 3430
3338#if EV_SIGNAL_ENABLE 3431#if EV_SIGNAL_ENABLE
3339 3432
3340void noinline 3433void noinline
3341ev_signal_start (EV_P_ ev_signal *w) 3434ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3342{ 3435{
3343 if (expect_false (ev_is_active (w))) 3436 if (expect_false (ev_is_active (w)))
3344 return; 3437 return;
3345 3438
3346 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG)); 3439 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
… …
3417 3510
3418 EV_FREQUENT_CHECK; 3511 EV_FREQUENT_CHECK;
3419} 3512}
3420 3513
3421void noinline 3514void noinline
3422ev_signal_stop (EV_P_ ev_signal *w) 3515ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3423{ 3516{
3424 clear_pending (EV_A_ (W)w); 3517 clear_pending (EV_A_ (W)w);
3425 if (expect_false (!ev_is_active (w))) 3518 if (expect_false (!ev_is_active (w)))
3426 return; 3519 return;
3427 3520
… …
3458#endif 3551#endif
3459 3552
3460#if EV_CHILD_ENABLE 3553#if EV_CHILD_ENABLE
3461 3554
3462void 3555void
3463ev_child_start (EV_P_ ev_child *w) 3556ev_child_start (EV_P_ ev_child *w) EV_THROW
3464{ 3557{
3465#if EV_MULTIPLICITY 3558#if EV_MULTIPLICITY
3466 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); 3559 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3467#endif 3560#endif
3468 if (expect_false (ev_is_active (w))) 3561 if (expect_false (ev_is_active (w)))
… …
3475 3568
3476 EV_FREQUENT_CHECK; 3569 EV_FREQUENT_CHECK;
3477} 3570}
3478 3571
3479void 3572void
3480ev_child_stop (EV_P_ ev_child *w) 3573ev_child_stop (EV_P_ ev_child *w) EV_THROW
3481{ 3574{
3482 clear_pending (EV_A_ (W)w); 3575 clear_pending (EV_A_ (W)w);
3483 if (expect_false (!ev_is_active (w))) 3576 if (expect_false (!ev_is_active (w)))
3484 return; 3577 return;
3485 3578
… …
3652} 3745}
3653 3746
3654inline_size int 3747inline_size int
3655infy_newfd (void) 3748infy_newfd (void)
3656{ 3749{
3657#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK) 3750#if defined IN_CLOEXEC && defined IN_NONBLOCK
3658 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK); 3751 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK);
3659 if (fd >= 0) 3752 if (fd >= 0)
3660 return fd; 3753 return fd;
3661#endif 3754#endif
3662 return inotify_init (); 3755 return inotify_init ();
… …
3737#else 3830#else
3738# define EV_LSTAT(p,b) lstat (p, b) 3831# define EV_LSTAT(p,b) lstat (p, b)
3739#endif 3832#endif
3740 3833
3741void 3834void
3742ev_stat_stat (EV_P_ ev_stat *w) 3835ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
3743{ 3836{
3744 if (lstat (w->path, &w->attr) < 0) 3837 if (lstat (w->path, &w->attr) < 0)
3745 w->attr.st_nlink = 0; 3838 w->attr.st_nlink = 0;
3746 else if (!w->attr.st_nlink) 3839 else if (!w->attr.st_nlink)
3747 w->attr.st_nlink = 1; 3840 w->attr.st_nlink = 1;
… …
3786 ev_feed_event (EV_A_ w, EV_STAT); 3879 ev_feed_event (EV_A_ w, EV_STAT);
3787 } 3880 }
3788} 3881}
3789 3882
3790void 3883void
3791ev_stat_start (EV_P_ ev_stat *w) 3884ev_stat_start (EV_P_ ev_stat *w) EV_THROW
3792{ 3885{
3793 if (expect_false (ev_is_active (w))) 3886 if (expect_false (ev_is_active (w)))
3794 return; 3887 return;
3795 3888
3796 ev_stat_stat (EV_A_ w); 3889 ev_stat_stat (EV_A_ w);
… …
3817 3910
3818 EV_FREQUENT_CHECK; 3911 EV_FREQUENT_CHECK;
3819} 3912}
3820 3913
3821void 3914void
3822ev_stat_stop (EV_P_ ev_stat *w) 3915ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
3823{ 3916{
3824 clear_pending (EV_A_ (W)w); 3917 clear_pending (EV_A_ (W)w);
3825 if (expect_false (!ev_is_active (w))) 3918 if (expect_false (!ev_is_active (w)))
3826 return; 3919 return;
3827 3920
… …
3843} 3936}
3844#endif 3937#endif
3845 3938
3846#if EV_IDLE_ENABLE 3939#if EV_IDLE_ENABLE
3847void 3940void
3848ev_idle_start (EV_P_ ev_idle *w) 3941ev_idle_start (EV_P_ ev_idle *w) EV_THROW
3849{ 3942{
3850 if (expect_false (ev_is_active (w))) 3943 if (expect_false (ev_is_active (w)))
3851 return; 3944 return;
3852 3945
3853 pri_adjust (EV_A_ (W)w); 3946 pri_adjust (EV_A_ (W)w);
… …
3866 3959
3867 EV_FREQUENT_CHECK; 3960 EV_FREQUENT_CHECK;
3868} 3961}
3869 3962
3870void 3963void
3871ev_idle_stop (EV_P_ ev_idle *w) 3964ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
3872{ 3965{
3873 clear_pending (EV_A_ (W)w); 3966 clear_pending (EV_A_ (W)w);
3874 if (expect_false (!ev_is_active (w))) 3967 if (expect_false (!ev_is_active (w)))
3875 return; 3968 return;
3876 3969
… …
3890} 3983}
3891#endif 3984#endif
3892 3985
3893#if EV_PREPARE_ENABLE 3986#if EV_PREPARE_ENABLE
3894void 3987void
3895ev_prepare_start (EV_P_ ev_prepare *w) 3988ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
3896{ 3989{
3897 if (expect_false (ev_is_active (w))) 3990 if (expect_false (ev_is_active (w)))
3898 return; 3991 return;
3899 3992
3900 EV_FREQUENT_CHECK; 3993 EV_FREQUENT_CHECK;
… …
3905 3998
3906 EV_FREQUENT_CHECK; 3999 EV_FREQUENT_CHECK;
3907} 4000}
3908 4001
3909void 4002void
3910ev_prepare_stop (EV_P_ ev_prepare *w) 4003ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
3911{ 4004{
3912 clear_pending (EV_A_ (W)w); 4005 clear_pending (EV_A_ (W)w);
3913 if (expect_false (!ev_is_active (w))) 4006 if (expect_false (!ev_is_active (w)))
3914 return; 4007 return;
3915 4008
… …
3928} 4021}
3929#endif 4022#endif
3930 4023
3931#if EV_CHECK_ENABLE 4024#if EV_CHECK_ENABLE
3932void 4025void
3933ev_check_start (EV_P_ ev_check *w) 4026ev_check_start (EV_P_ ev_check *w) EV_THROW
3934{ 4027{
3935 if (expect_false (ev_is_active (w))) 4028 if (expect_false (ev_is_active (w)))
3936 return; 4029 return;
3937 4030
3938 EV_FREQUENT_CHECK; 4031 EV_FREQUENT_CHECK;
… …
3943 4036
3944 EV_FREQUENT_CHECK; 4037 EV_FREQUENT_CHECK;
3945} 4038}
3946 4039
3947void 4040void
3948ev_check_stop (EV_P_ ev_check *w) 4041ev_check_stop (EV_P_ ev_check *w) EV_THROW
3949{ 4042{
3950 clear_pending (EV_A_ (W)w); 4043 clear_pending (EV_A_ (W)w);
3951 if (expect_false (!ev_is_active (w))) 4044 if (expect_false (!ev_is_active (w)))
3952 return; 4045 return;
3953 4046
… …
3966} 4059}
3967#endif 4060#endif
3968 4061
3969#if EV_EMBED_ENABLE 4062#if EV_EMBED_ENABLE
3970void noinline 4063void noinline
3971ev_embed_sweep (EV_P_ ev_embed *w) 4064ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
3972{ 4065{
3973 ev_run (w->other, EVRUN_NOWAIT); 4066 ev_run (w->other, EVRUN_NOWAIT);
3974} 4067}
3975 4068
3976static void 4069static void
… …
4024 ev_idle_stop (EV_A_ idle); 4117 ev_idle_stop (EV_A_ idle);
4025} 4118}
4026#endif 4119#endif
4027 4120
4028void 4121void
4029ev_embed_start (EV_P_ ev_embed *w) 4122ev_embed_start (EV_P_ ev_embed *w) EV_THROW
4030{ 4123{
4031 if (expect_false (ev_is_active (w))) 4124 if (expect_false (ev_is_active (w)))
4032 return; 4125 return;
4033 4126
4034 { 4127 {
… …
4055 4148
4056 EV_FREQUENT_CHECK; 4149 EV_FREQUENT_CHECK;
4057} 4150}
4058 4151
4059void 4152void
4060ev_embed_stop (EV_P_ ev_embed *w) 4153ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
4061{ 4154{
4062 clear_pending (EV_A_ (W)w); 4155 clear_pending (EV_A_ (W)w);
4063 if (expect_false (!ev_is_active (w))) 4156 if (expect_false (!ev_is_active (w)))
4064 return; 4157 return;
4065 4158
… …
4075} 4168}
4076#endif 4169#endif
4077 4170
4078#if EV_FORK_ENABLE 4171#if EV_FORK_ENABLE
4079void 4172void
4080ev_fork_start (EV_P_ ev_fork *w) 4173ev_fork_start (EV_P_ ev_fork *w) EV_THROW
4081{ 4174{
4082 if (expect_false (ev_is_active (w))) 4175 if (expect_false (ev_is_active (w)))
4083 return; 4176 return;
4084 4177
4085 EV_FREQUENT_CHECK; 4178 EV_FREQUENT_CHECK;
… …
4090 4183
4091 EV_FREQUENT_CHECK; 4184 EV_FREQUENT_CHECK;
4092} 4185}
4093 4186
4094void 4187void
4095ev_fork_stop (EV_P_ ev_fork *w) 4188ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
4096{ 4189{
4097 clear_pending (EV_A_ (W)w); 4190 clear_pending (EV_A_ (W)w);
4098 if (expect_false (!ev_is_active (w))) 4191 if (expect_false (!ev_is_active (w)))
4099 return; 4192 return;
4100 4193
… …
4113} 4206}
4114#endif 4207#endif
4115 4208
4116#if EV_CLEANUP_ENABLE 4209#if EV_CLEANUP_ENABLE
4117void 4210void
4118ev_cleanup_start (EV_P_ ev_cleanup *w) 4211ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
4119{ 4212{
4120 if (expect_false (ev_is_active (w))) 4213 if (expect_false (ev_is_active (w)))
4121 return; 4214 return;
4122 4215
4123 EV_FREQUENT_CHECK; 4216 EV_FREQUENT_CHECK;
… …
4130 ev_unref (EV_A); 4223 ev_unref (EV_A);
4131 EV_FREQUENT_CHECK; 4224 EV_FREQUENT_CHECK;
4132} 4225}
4133 4226
4134void 4227void
4135ev_cleanup_stop (EV_P_ ev_cleanup *w) 4228ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
4136{ 4229{
4137 clear_pending (EV_A_ (W)w); 4230 clear_pending (EV_A_ (W)w);
4138 if (expect_false (!ev_is_active (w))) 4231 if (expect_false (!ev_is_active (w)))
4139 return; 4232 return;
4140 4233
… …
4154} 4247}
4155#endif 4248#endif
4156 4249
4157#if EV_ASYNC_ENABLE 4250#if EV_ASYNC_ENABLE
4158void 4251void
4159ev_async_start (EV_P_ ev_async *w) 4252ev_async_start (EV_P_ ev_async *w) EV_THROW
4160{ 4253{
4161 if (expect_false (ev_is_active (w))) 4254 if (expect_false (ev_is_active (w)))
4162 return; 4255 return;
4163 4256
4164 w->sent = 0; 4257 w->sent = 0;
… …
4173 4266
4174 EV_FREQUENT_CHECK; 4267 EV_FREQUENT_CHECK;
4175} 4268}
4176 4269
4177void 4270void
4178ev_async_stop (EV_P_ ev_async *w) 4271ev_async_stop (EV_P_ ev_async *w) EV_THROW
4179{ 4272{
4180 clear_pending (EV_A_ (W)w); 4273 clear_pending (EV_A_ (W)w);
4181 if (expect_false (!ev_is_active (w))) 4274 if (expect_false (!ev_is_active (w)))
4182 return; 4275 return;
4183 4276
… …
4194 4287
4195 EV_FREQUENT_CHECK; 4288 EV_FREQUENT_CHECK;
4196} 4289}
4197 4290
4198void 4291void
4199ev_async_send (EV_P_ ev_async *w) 4292ev_async_send (EV_P_ ev_async *w) EV_THROW
4200{ 4293{
4201 w->sent = 1; 4294 w->sent = 1;
4202 evpipe_write (EV_A_ &async_pending); 4295 evpipe_write (EV_A_ &async_pending);
4203} 4296}
4204#endif 4297#endif
… …
4241 4334
4242 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io)); 4335 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4243} 4336}
4244 4337
4245void 4338void
4246ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) 4339ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW
4247{ 4340{
4248 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once)); 4341 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
4249 4342
4250 if (expect_false (!once)) 4343 if (expect_false (!once))
4251 { 4344 {
… …
4273 4366
4274/*****************************************************************************/ 4367/*****************************************************************************/
4275 4368
4276#if EV_WALK_ENABLE 4369#if EV_WALK_ENABLE
4277void ecb_cold 4370void ecb_cold
4278ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) 4371ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
4279{ 4372{
4280 int i, j; 4373 int i, j;
4281 ev_watcher_list *wl, *wn; 4374 ev_watcher_list *wl, *wn;
4282 4375
4283 if (types & (EV_IO | EV_EMBED)) 4376 if (types & (EV_IO | EV_EMBED))
… …
4389 4482
4390#if EV_MULTIPLICITY 4483#if EV_MULTIPLICITY
4391 #include "ev_wrap.h" 4484 #include "ev_wrap.h"
4392#endif 4485#endif
4393 4486
4394EV_CPP(})
4395

Diff Legend

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