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

Comparing libev/ev.c (file contents):
Revision 1.383 by root, Wed Jul 20 00:40:14 2011 UTC vs.
Revision 1.419 by root, Thu Apr 12 04:10:15 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
… …
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__
… …
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
496 652
497#ifndef ECB_MEMORY_FENCE
498 #if ECB_GCC_VERSION(2,5) 653#if ECB_GCC_VERSION(3,3)
499 #if __x86 654 #define ecb_restrict __restrict__
500 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory") 655#elif ECB_C99
501 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE 656 #define ecb_restrict restrict
502 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE /* better be safe than sorry */ 657#else
503 #elif __amd64 658 #define ecb_restrict
504 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
505 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")
506 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence")
507 #endif
508 #endif 659#endif
509#endif
510 660
511#ifndef ECB_MEMORY_FENCE 661typedef int ecb_bool;
512 #if ECB_GCC_VERSION(4,4)
513 #define ECB_MEMORY_FENCE __sync_synchronize ()
514 #define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); })
515 #define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); })
516 #elif _MSC_VER >= 1400
517 #define ECB_MEMORY_FENCE do { } while (0)
518 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
519 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
520 #elif defined(_WIN32) && defined(MemoryBarrier)
521 #define ECB_MEMORY_FENCE MemoryBarrier ()
522 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
523 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
524 #endif
525#endif
526 662
527#ifndef ECB_MEMORY_FENCE 663#define ECB_CONCAT_(a, b) a ## b
528 #include <pthread.h> 664#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
665#define ECB_STRINGIFY_(a) # a
666#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
529 667
530 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER; 668#define ecb_function_ ecb_inline
531 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
532 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
533 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
534#endif
535 669
536#if ECB_GCC_VERSION(3,1) 670#if ECB_GCC_VERSION(3,1)
537 #define ecb_attribute(attrlist) __attribute__(attrlist) 671 #define ecb_attribute(attrlist) __attribute__(attrlist)
538 #define ecb_is_constant(expr) __builtin_constant_p (expr) 672 #define ecb_is_constant(expr) __builtin_constant_p (expr)
539 #define ecb_expect(expr,value) __builtin_expect ((expr),(value)) 673 #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
… …
543 #define ecb_is_constant(expr) 0 677 #define ecb_is_constant(expr) 0
544 #define ecb_expect(expr,value) (expr) 678 #define ecb_expect(expr,value) (expr)
545 #define ecb_prefetch(addr,rw,locality) 679 #define ecb_prefetch(addr,rw,locality)
546#endif 680#endif
547 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
548#define ecb_noinline ecb_attribute ((__noinline__)) 689#define ecb_noinline ecb_attribute ((__noinline__))
549#define ecb_noreturn ecb_attribute ((__noreturn__)) 690#define ecb_noreturn ecb_attribute ((__noreturn__))
550#define ecb_unused ecb_attribute ((__unused__)) 691#define ecb_unused ecb_attribute ((__unused__))
551#define ecb_const ecb_attribute ((__const__)) 692#define ecb_const ecb_attribute ((__const__))
552#define ecb_pure ecb_attribute ((__pure__)) 693#define ecb_pure ecb_attribute ((__pure__))
… …
564/* put around conditional expressions if you are very sure that the */ 705/* put around conditional expressions if you are very sure that the */
565/* expression is mostly true or mostly false. note that these return */ 706/* expression is mostly true or mostly false. note that these return */
566/* booleans, not the expression. */ 707/* booleans, not the expression. */
567#define ecb_expect_false(expr) ecb_expect (!!(expr), 0) 708#define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
568#define ecb_expect_true(expr) ecb_expect (!!(expr), 1) 709#define ecb_expect_true(expr) ecb_expect (!!(expr), 1)
569/* 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
570 955
571#define expect_false(cond) ecb_expect_false (cond) 956#define expect_false(cond) ecb_expect_false (cond)
572#define expect_true(cond) ecb_expect_true (cond) 957#define expect_true(cond) ecb_expect_true (cond)
573#define noinline ecb_noinline 958#define noinline ecb_noinline
574 959
… …
870 #undef VAR 1255 #undef VAR
871 }; 1256 };
872 #include "ev_wrap.h" 1257 #include "ev_wrap.h"
873 1258
874 static struct ev_loop default_loop_struct; 1259 static struct ev_loop default_loop_struct;
875 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 */
876 1261
877#else 1262#else
878 1263
879 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 */
880 #define VAR(name,decl) static decl; 1265 #define VAR(name,decl) static decl;
881 #include "ev_vars.h" 1266 #include "ev_vars.h"
882 #undef VAR 1267 #undef VAR
883 1268
884 static int ev_default_loop_ptr; 1269 static int ev_default_loop_ptr;
… …
949#if EV_USE_NANOSLEEP 1334#if EV_USE_NANOSLEEP
950 struct timespec ts; 1335 struct timespec ts;
951 1336
952 EV_TS_SET (ts, delay); 1337 EV_TS_SET (ts, delay);
953 nanosleep (&ts, 0); 1338 nanosleep (&ts, 0);
954#elif defined(_WIN32) 1339#elif defined _WIN32
955 Sleep ((unsigned long)(delay * 1e3)); 1340 Sleep ((unsigned long)(delay * 1e3));
956#else 1341#else
957 struct timeval tv; 1342 struct timeval tv;
958 1343
959 /* 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 */
… …
978 1363
979 do 1364 do
980 ncur <<= 1; 1365 ncur <<= 1;
981 while (cnt > ncur); 1366 while (cnt > ncur);
982 1367
983 /* 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 */
984 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4) 1369 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
985 { 1370 {
986 ncur *= elem; 1371 ncur *= elem;
987 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);
988 ncur = ncur - sizeof (void *) * 4; 1373 ncur = ncur - sizeof (void *) * 4;
… …
1464 if (expect_true (*flag)) 1849 if (expect_true (*flag))
1465 return; 1850 return;
1466 1851
1467 *flag = 1; 1852 *flag = 1;
1468 1853
1469 ECB_MEMORY_FENCE_RELEASE; 1854 ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
1470 1855
1471 pipe_write_skipped = 1; 1856 pipe_write_skipped = 1;
1472 1857
1473 ECB_MEMORY_FENCE; 1858 ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
1474 1859
1475 if (pipe_write_wanted) 1860 if (pipe_write_wanted)
1476 { 1861 {
1477 int old_errno; 1862 int old_errno;
1478 1863
1479 pipe_write_skipped = 0; /* optimisation only */ 1864 pipe_write_skipped = 0; /* just an optimisation, no fence needed */
1480 1865
1481 old_errno = errno; /* save errno because write will clobber it */ 1866 old_errno = errno; /* save errno because write will clobber it */
1482 1867
1483#if EV_USE_EVENTFD 1868#if EV_USE_EVENTFD
1484 if (evfd >= 0) 1869 if (evfd >= 0)
… …
1492 /* win32 people keep sending patches that change this write() to send() */ 1877 /* win32 people keep sending patches that change this write() to send() */
1493 /* 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 */
1494 /* 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 */
1495 /* 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 */
1496 /* 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 */
1497 write (evpipe [1], &(evpipe [1]), 1); 1884 write (evpipe [1], &(evpipe [1]), 1);
1498 } 1885 }
1499 1886
1500 errno = old_errno; 1887 errno = old_errno;
1501 } 1888 }
… …
2545 2932
2546 mn_now = ev_rt_now; 2933 mn_now = ev_rt_now;
2547 } 2934 }
2548} 2935}
2549 2936
2550void 2937int
2551ev_run (EV_P_ int flags) 2938ev_run (EV_P_ int flags)
2552{ 2939{
2553#if EV_FEATURE_API 2940#if EV_FEATURE_API
2554 ++loop_depth; 2941 ++loop_depth;
2555#endif 2942#endif
… …
2616 time_update (EV_A_ 1e100); 3003 time_update (EV_A_ 1e100);
2617 3004
2618 /* from now on, we want a pipe-wake-up */ 3005 /* from now on, we want a pipe-wake-up */
2619 pipe_write_wanted = 1; 3006 pipe_write_wanted = 1;
2620 3007
2621 ECB_MEMORY_FENCE; 3008 ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
2622 3009
2623 if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped))) 3010 if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
2624 { 3011 {
2625 waittime = MAX_BLOCKTIME; 3012 waittime = MAX_BLOCKTIME;
2626 3013
… …
2668#endif 3055#endif
2669 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */ 3056 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
2670 backend_poll (EV_A_ waittime); 3057 backend_poll (EV_A_ waittime);
2671 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */ 3058 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
2672 3059
2673 pipe_write_wanted = 0; 3060 pipe_write_wanted = 0; /* just an optimisation, no fence needed */
2674 3061
2675 if (pipe_write_skipped) 3062 if (pipe_write_skipped)
2676 { 3063 {
2677 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)));
2678 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM); 3065 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
… …
2712 loop_done = EVBREAK_CANCEL; 3099 loop_done = EVBREAK_CANCEL;
2713 3100
2714#if EV_FEATURE_API 3101#if EV_FEATURE_API
2715 --loop_depth; 3102 --loop_depth;
2716#endif 3103#endif
3104
3105 return activecnt;
2717} 3106}
2718 3107
2719void 3108void
2720ev_break (EV_P_ int how) 3109ev_break (EV_P_ int how)
2721{ 3110{
… …
2936 3325
2937void noinline 3326void noinline
2938ev_timer_again (EV_P_ ev_timer *w) 3327ev_timer_again (EV_P_ ev_timer *w)
2939{ 3328{
2940 EV_FREQUENT_CHECK; 3329 EV_FREQUENT_CHECK;
3330
3331 clear_pending (EV_A_ (W)w);
2941 3332
2942 if (ev_is_active (w)) 3333 if (ev_is_active (w))
2943 { 3334 {
2944 if (w->repeat) 3335 if (w->repeat)
2945 { 3336 {
… …
3354} 3745}
3355 3746
3356inline_size int 3747inline_size int
3357infy_newfd (void) 3748infy_newfd (void)
3358{ 3749{
3359#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK) 3750#if defined IN_CLOEXEC && defined IN_NONBLOCK
3360 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK); 3751 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK);
3361 if (fd >= 0) 3752 if (fd >= 0)
3362 return fd; 3753 return fd;
3363#endif 3754#endif
3364 return inotify_init (); 3755 return inotify_init ();
… …
4028 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i])); 4419 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
4029#endif 4420#endif
4030 4421
4031#if EV_IDLE_ENABLE 4422#if EV_IDLE_ENABLE
4032 if (types & EV_IDLE) 4423 if (types & EV_IDLE)
4033 for (j = NUMPRI; i--; ) 4424 for (j = NUMPRI; j--; )
4034 for (i = idlecnt [j]; i--; ) 4425 for (i = idlecnt [j]; i--; )
4035 cb (EV_A_ EV_IDLE, idles [j][i]); 4426 cb (EV_A_ EV_IDLE, idles [j][i]);
4036#endif 4427#endif
4037 4428
4038#if EV_FORK_ENABLE 4429#if EV_FORK_ENABLE
… …
4091 4482
4092#if EV_MULTIPLICITY 4483#if EV_MULTIPLICITY
4093 #include "ev_wrap.h" 4484 #include "ev_wrap.h"
4094#endif 4485#endif
4095 4486
4096EV_CPP(})
4097

Diff Legend

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