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

Comparing libev/ev.c (file contents):
Revision 1.448 by root, Tue Jul 24 16:28:08 2012 UTC vs.
Revision 1.467 by root, Fri May 16 15:15:39 2014 UTC

1/* 1/*
2 * libev event processing core, watcher management 2 * libev event processing core, watcher management
3 * 3 *
4 * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de> 4 * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 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 *
… …
241#elif defined SIGARRAYSIZE 241#elif defined SIGARRAYSIZE
242# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */ 242# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
243#elif defined _sys_nsig 243#elif defined _sys_nsig
244# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */ 244# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
245#else 245#else
246# error "unable to find value for NSIG, please report" 246# define EV_NSIG (8 * sizeof (sigset_t) + 1)
247/* to make it compile regardless, just remove the above line, */
248/* but consider reporting it, too! :) */
249# define EV_NSIG 65
250#endif 247#endif
251 248
252#ifndef EV_USE_FLOOR 249#ifndef EV_USE_FLOOR
253# define EV_USE_FLOOR 0 250# define EV_USE_FLOOR 0
254#endif 251#endif
255 252
256#ifndef EV_USE_CLOCK_SYSCALL 253#ifndef EV_USE_CLOCK_SYSCALL
257# if __linux && __GLIBC__ >= 2 254# if __linux && __GLIBC__ == 2 && __GLIBC_MINOR__ < 17
258# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS 255# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
259# else 256# else
260# define EV_USE_CLOCK_SYSCALL 0 257# define EV_USE_CLOCK_SYSCALL 0
261# endif 258# endif
262#endif 259#endif
… …
355# define EV_USE_4HEAP EV_FEATURE_DATA 352# define EV_USE_4HEAP EV_FEATURE_DATA
356#endif 353#endif
357 354
358#ifndef EV_HEAP_CACHE_AT 355#ifndef EV_HEAP_CACHE_AT
359# define EV_HEAP_CACHE_AT EV_FEATURE_DATA 356# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
357#endif
358
359#ifdef ANDROID
360/* supposedly, android doesn't typedef fd_mask */
361# undef EV_USE_SELECT
362# define EV_USE_SELECT 0
363/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
364# undef EV_USE_CLOCK_SYSCALL
365# define EV_USE_CLOCK_SYSCALL 0
366#endif
367
368/* aix's poll.h seems to cause lots of trouble */
369#ifdef _AIX
370/* AIX has a completely broken poll.h header */
371# undef EV_USE_POLL
372# define EV_USE_POLL 0
360#endif 373#endif
361 374
362/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */ 375/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
363/* which makes programs even slower. might work on other unices, too. */ 376/* which makes programs even slower. might work on other unices, too. */
364#if EV_USE_CLOCK_SYSCALL 377#if EV_USE_CLOCK_SYSCALL
… …
372# define EV_USE_CLOCK_SYSCALL 0 385# define EV_USE_CLOCK_SYSCALL 0
373# endif 386# endif
374#endif 387#endif
375 388
376/* this block fixes any misconfiguration where we know we run into trouble otherwise */ 389/* this block fixes any misconfiguration where we know we run into trouble otherwise */
377
378#ifdef _AIX
379/* AIX has a completely broken poll.h header */
380# undef EV_USE_POLL
381# define EV_USE_POLL 0
382#endif
383 390
384#ifndef CLOCK_MONOTONIC 391#ifndef CLOCK_MONOTONIC
385# undef EV_USE_MONOTONIC 392# undef EV_USE_MONOTONIC
386# define EV_USE_MONOTONIC 0 393# define EV_USE_MONOTONIC 0
387#endif 394#endif
… …
475/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */ 482/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
476/* ECB.H BEGIN */ 483/* ECB.H BEGIN */
477/* 484/*
478 * libecb - http://software.schmorp.de/pkg/libecb 485 * libecb - http://software.schmorp.de/pkg/libecb
479 * 486 *
480 * Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de> 487 * Copyright (©) 2009-2014 Marc Alexander Lehmann <libecb@schmorp.de>
481 * Copyright (©) 2011 Emanuele Giaquinta 488 * Copyright (©) 2011 Emanuele Giaquinta
482 * All rights reserved. 489 * All rights reserved.
483 * 490 *
484 * Redistribution and use in source and binary forms, with or without modifica- 491 * Redistribution and use in source and binary forms, with or without modifica-
485 * tion, are permitted provided that the following conditions are met: 492 * tion, are permitted provided that the following conditions are met:
… …
499 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 506 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
500 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 507 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
501 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH- 508 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
502 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 509 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
503 * OF THE POSSIBILITY OF SUCH DAMAGE. 510 * OF THE POSSIBILITY OF SUCH DAMAGE.
511 *
512 * Alternatively, the contents of this file may be used under the terms of
513 * the GNU General Public License ("GPL") version 2 or any later version,
514 * in which case the provisions of the GPL are applicable instead of
515 * the above. If you wish to allow the use of your version of this file
516 * only under the terms of the GPL and not to allow others to use your
517 * version of this file under the BSD license, indicate your decision
518 * by deleting the provisions above and replace them with the notice
519 * and other provisions required by the GPL. If you do not delete the
520 * provisions above, a recipient may use your version of this file under
521 * either the BSD or the GPL.
504 */ 522 */
505 523
506#ifndef ECB_H 524#ifndef ECB_H
507#define ECB_H 525#define ECB_H
508 526
509/* 16 bits major, 16 bits minor */ 527/* 16 bits major, 16 bits minor */
510#define ECB_VERSION 0x00010001 528#define ECB_VERSION 0x00010003
511 529
512#ifdef _WIN32 530#ifdef _WIN32
513 typedef signed char int8_t; 531 typedef signed char int8_t;
514 typedef unsigned char uint8_t; 532 typedef unsigned char uint8_t;
515 typedef signed short int16_t; 533 typedef signed short int16_t;
… …
530 #else 548 #else
531 #define ECB_PTRSIZE 4 549 #define ECB_PTRSIZE 4
532 typedef uint32_t uintptr_t; 550 typedef uint32_t uintptr_t;
533 typedef int32_t intptr_t; 551 typedef int32_t intptr_t;
534 #endif 552 #endif
535 typedef intptr_t ptrdiff_t;
536#else 553#else
537 #include <inttypes.h> 554 #include <inttypes.h>
538 #if UINTMAX_MAX > 0xffffffffU 555 #if UINTMAX_MAX > 0xffffffffU
539 #define ECB_PTRSIZE 8 556 #define ECB_PTRSIZE 8
540 #else 557 #else
541 #define ECB_PTRSIZE 4 558 #define ECB_PTRSIZE 4
559 #endif
560#endif
561
562/* work around x32 idiocy by defining proper macros */
563#if __amd64 || __x86_64 || _M_AMD64 || _M_X64
564 #if _ILP32
565 #define ECB_AMD64_X32 1
566 #else
567 #define ECB_AMD64 1
542 #endif 568 #endif
543#endif 569#endif
544 570
545/* many compilers define _GNUC_ to some versions but then only implement 571/* many compilers define _GNUC_ to some versions but then only implement
546 * what their idiot authors think are the "more important" extensions, 572 * what their idiot authors think are the "more important" extensions,
… …
555 #else 581 #else
556 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) 582 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
557 #endif 583 #endif
558#endif 584#endif
559 585
560#define ECB_C (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */
561#define ECB_C99 (__STDC_VERSION__ >= 199901L)
562#define ECB_C11 (__STDC_VERSION__ >= 201112L)
563#define ECB_CPP (__cplusplus+0) 586#define ECB_CPP (__cplusplus+0)
564#define ECB_CPP11 (__cplusplus >= 201103L) 587#define ECB_CPP11 (__cplusplus >= 201103L)
588
589#if ECB_CPP
590 #define ECB_C 0
591 #define ECB_STDC_VERSION 0
592#else
593 #define ECB_C 1
594 #define ECB_STDC_VERSION __STDC_VERSION__
595#endif
596
597#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
598#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
599
600#if ECB_CPP
601 #define ECB_EXTERN_C extern "C"
602 #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
603 #define ECB_EXTERN_C_END }
604#else
605 #define ECB_EXTERN_C extern
606 #define ECB_EXTERN_C_BEG
607 #define ECB_EXTERN_C_END
608#endif
565 609
566/*****************************************************************************/ 610/*****************************************************************************/
567 611
568/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */ 612/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
569/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */ 613/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
… …
592 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ 636 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
593 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory") 637 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
594 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \ 638 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
595 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__ 639 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
596 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory") 640 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
641 #elif __aarch64__
642 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
597 #elif __sparc || __sparc__ 643 #elif (__sparc || __sparc__) && !__sparcv8
598 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory") 644 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
599 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory") 645 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
600 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore") 646 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
601 #elif defined __s390__ || defined __s390x__ 647 #elif defined __s390__ || defined __s390x__
602 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory") 648 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
603 #elif defined __mips__ 649 #elif defined __mips__
650 /* GNU/Linux emulates sync on mips1 architectures, so we force its use */
651 /* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
604 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 652 #define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
605 #elif defined __alpha__ 653 #elif defined __alpha__
606 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory") 654 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
607 #elif defined __hppa__ 655 #elif defined __hppa__
608 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory") 656 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
609 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("") 657 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
610 #elif defined __ia64__ 658 #elif defined __ia64__
611 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory") 659 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
660 #elif defined __m68k__
661 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
662 #elif defined __m88k__
663 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
664 #elif defined __sh__
665 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
612 #endif 666 #endif
613 #endif 667 #endif
614#endif 668#endif
615 669
616#ifndef ECB_MEMORY_FENCE 670#ifndef ECB_MEMORY_FENCE
617 #if ECB_GCC_VERSION(4,7) 671 #if ECB_GCC_VERSION(4,7)
618 /* see comment below (stdatomic.h) about the C11 memory model. */ 672 /* see comment below (stdatomic.h) about the C11 memory model. */
619 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST) 673 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
674 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
675 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
676
677 /* The __has_feature syntax from clang is so misdesigned that we cannot use it
678 * without risking compile time errors with other compilers. We *could*
679 * define our own ecb_clang_has_feature, but I just can't be bothered to work
680 * around this shit time and again.
620 #elif defined __clang && __has_feature (cxx_atomic) 681 * #elif defined __clang && __has_feature (cxx_atomic)
621 /* see comment below (stdatomic.h) about the C11 memory model. */ 682 * // see comment below (stdatomic.h) about the C11 memory model.
622 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST) 683 * #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
684 * #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
685 * #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
686 */
687
623 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__ 688 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
624 #define ECB_MEMORY_FENCE __sync_synchronize () 689 #define ECB_MEMORY_FENCE __sync_synchronize ()
690 #elif _MSC_VER >= 1500 /* VC++ 2008 */
691 /* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
692 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
693 #define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
694 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
695 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
625 #elif _MSC_VER >= 1400 /* VC++ 2005 */ 696 #elif _MSC_VER >= 1400 /* VC++ 2005 */
626 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier) 697 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
627 #define ECB_MEMORY_FENCE _ReadWriteBarrier () 698 #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
628 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */ 699 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
629 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier () 700 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
… …
649 /* any fence other than seq_cst, which isn't very efficient for us. */ 720 /* any fence other than seq_cst, which isn't very efficient for us. */
650 /* Why that is, we don't know - either the C11 memory model is quite useless */ 721 /* Why that is, we don't know - either the C11 memory model is quite useless */
651 /* for most usages, or gcc and clang have a bug */ 722 /* for most usages, or gcc and clang have a bug */
652 /* I *currently* lean towards the latter, and inefficiently implement */ 723 /* I *currently* lean towards the latter, and inefficiently implement */
653 /* all three of ecb's fences as a seq_cst fence */ 724 /* all three of ecb's fences as a seq_cst fence */
725 /* Update, gcc-4.8 generates mfence for all c++ fences, but nothing */
726 /* for all __atomic_thread_fence's except seq_cst */
654 #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst) 727 #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
655 #endif 728 #endif
656#endif 729#endif
657 730
658#ifndef ECB_MEMORY_FENCE 731#ifndef ECB_MEMORY_FENCE
… …
715 #define ecb_is_constant(expr) __builtin_constant_p (expr) 788 #define ecb_is_constant(expr) __builtin_constant_p (expr)
716 #define ecb_expect(expr,value) __builtin_expect ((expr),(value)) 789 #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
717 #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality) 790 #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
718#else 791#else
719 #define ecb_attribute(attrlist) 792 #define ecb_attribute(attrlist)
793
794 /* possible C11 impl for integral types
795 typedef struct ecb_is_constant_struct ecb_is_constant_struct;
796 #define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
797
720 #define ecb_is_constant(expr) 0 798 #define ecb_is_constant(expr) 0
721 #define ecb_expect(expr,value) (expr) 799 #define ecb_expect(expr,value) (expr)
722 #define ecb_prefetch(addr,rw,locality) 800 #define ecb_prefetch(addr,rw,locality)
723#endif 801#endif
724 802
… …
935 ecb_inline void ecb_unreachable (void) ecb_noreturn; 1013 ecb_inline void ecb_unreachable (void) ecb_noreturn;
936 ecb_inline void ecb_unreachable (void) { } 1014 ecb_inline void ecb_unreachable (void) { }
937#endif 1015#endif
938 1016
939/* try to tell the compiler that some condition is definitely true */ 1017/* try to tell the compiler that some condition is definitely true */
940#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0) 1018#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
941 1019
942ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const; 1020ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
943ecb_inline unsigned char 1021ecb_inline unsigned char
944ecb_byteorder_helper (void) 1022ecb_byteorder_helper (void)
945{ 1023{
946 const uint32_t u = 0x11223344; 1024 /* the union code still generates code under pressure in gcc, */
947 return *(unsigned char *)&u; 1025 /* but less than using pointers, and always seems to */
1026 /* successfully return a constant. */
1027 /* the reason why we have this horrible preprocessor mess */
1028 /* is to avoid it in all cases, at least on common architectures */
1029 /* or when using a recent enough gcc version (>= 4.6) */
1030#if __i386 || __i386__ || _M_X86 || __amd64 || __amd64__ || _M_X64
1031 return 0x44;
1032#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1033 return 0x44;
1034#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1035 return 0x11;
1036#else
1037 union
1038 {
1039 uint32_t i;
1040 uint8_t c;
1041 } u = { 0x11223344 };
1042 return u.c;
1043#endif
948} 1044}
949 1045
950ecb_inline ecb_bool ecb_big_endian (void) ecb_const; 1046ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
951ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; } 1047ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
952ecb_inline ecb_bool ecb_little_endian (void) ecb_const; 1048ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
… …
981 { 1077 {
982 return N; 1078 return N;
983 } 1079 }
984#else 1080#else
985 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 1081 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1082#endif
1083
1084/*******************************************************************************/
1085/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
1086
1087/* basically, everything uses "ieee pure-endian" floating point numbers */
1088/* the only noteworthy exception is ancient armle, which uses order 43218765 */
1089#if 0 \
1090 || __i386 || __i386__ \
1091 || __amd64 || __amd64__ || __x86_64 || __x86_64__ \
1092 || __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
1093 || defined __s390__ || defined __s390x__ \
1094 || defined __mips__ \
1095 || defined __alpha__ \
1096 || defined __hppa__ \
1097 || defined __ia64__ \
1098 || defined __m68k__ \
1099 || defined __m88k__ \
1100 || defined __sh__ \
1101 || defined _M_IX86 || defined _M_AMD64 || defined _M_IA64 \
1102 || (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
1103 || defined __aarch64__
1104 #define ECB_STDFP 1
1105 #include <string.h> /* for memcpy */
1106#else
1107 #define ECB_STDFP 0
1108#endif
1109
1110#ifndef ECB_NO_LIBM
1111
1112 #include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
1113
1114 /* only the oldest of old doesn't have this one. solaris. */
1115 #ifdef INFINITY
1116 #define ECB_INFINITY INFINITY
1117 #else
1118 #define ECB_INFINITY HUGE_VAL
1119 #endif
1120
1121 #ifdef NAN
1122 #define ECB_NAN NAN
1123 #else
1124 #define ECB_NAN ECB_INFINITY
1125 #endif
1126
1127 /* converts an ieee half/binary16 to a float */
1128 ecb_function_ float ecb_binary16_to_float (uint16_t x) ecb_const;
1129 ecb_function_ float
1130 ecb_binary16_to_float (uint16_t x)
1131 {
1132 int e = (x >> 10) & 0x1f;
1133 int m = x & 0x3ff;
1134 float r;
1135
1136 if (!e ) r = ldexpf (m , -24);
1137 else if (e != 31) r = ldexpf (m + 0x400, e - 25);
1138 else if (m ) r = ECB_NAN;
1139 else r = ECB_INFINITY;
1140
1141 return x & 0x8000 ? -r : r;
1142 }
1143
1144 /* convert a float to ieee single/binary32 */
1145 ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
1146 ecb_function_ uint32_t
1147 ecb_float_to_binary32 (float x)
1148 {
1149 uint32_t r;
1150
1151 #if ECB_STDFP
1152 memcpy (&r, &x, 4);
1153 #else
1154 /* slow emulation, works for anything but -0 */
1155 uint32_t m;
1156 int e;
1157
1158 if (x == 0e0f ) return 0x00000000U;
1159 if (x > +3.40282346638528860e+38f) return 0x7f800000U;
1160 if (x < -3.40282346638528860e+38f) return 0xff800000U;
1161 if (x != x ) return 0x7fbfffffU;
1162
1163 m = frexpf (x, &e) * 0x1000000U;
1164
1165 r = m & 0x80000000U;
1166
1167 if (r)
1168 m = -m;
1169
1170 if (e <= -126)
1171 {
1172 m &= 0xffffffU;
1173 m >>= (-125 - e);
1174 e = -126;
1175 }
1176
1177 r |= (e + 126) << 23;
1178 r |= m & 0x7fffffU;
1179 #endif
1180
1181 return r;
1182 }
1183
1184 /* converts an ieee single/binary32 to a float */
1185 ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
1186 ecb_function_ float
1187 ecb_binary32_to_float (uint32_t x)
1188 {
1189 float r;
1190
1191 #if ECB_STDFP
1192 memcpy (&r, &x, 4);
1193 #else
1194 /* emulation, only works for normals and subnormals and +0 */
1195 int neg = x >> 31;
1196 int e = (x >> 23) & 0xffU;
1197
1198 x &= 0x7fffffU;
1199
1200 if (e)
1201 x |= 0x800000U;
1202 else
1203 e = 1;
1204
1205 /* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
1206 r = ldexpf (x * (0.5f / 0x800000U), e - 126);
1207
1208 r = neg ? -r : r;
1209 #endif
1210
1211 return r;
1212 }
1213
1214 /* convert a double to ieee double/binary64 */
1215 ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
1216 ecb_function_ uint64_t
1217 ecb_double_to_binary64 (double x)
1218 {
1219 uint64_t r;
1220
1221 #if ECB_STDFP
1222 memcpy (&r, &x, 8);
1223 #else
1224 /* slow emulation, works for anything but -0 */
1225 uint64_t m;
1226 int e;
1227
1228 if (x == 0e0 ) return 0x0000000000000000U;
1229 if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
1230 if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
1231 if (x != x ) return 0X7ff7ffffffffffffU;
1232
1233 m = frexp (x, &e) * 0x20000000000000U;
1234
1235 r = m & 0x8000000000000000;;
1236
1237 if (r)
1238 m = -m;
1239
1240 if (e <= -1022)
1241 {
1242 m &= 0x1fffffffffffffU;
1243 m >>= (-1021 - e);
1244 e = -1022;
1245 }
1246
1247 r |= ((uint64_t)(e + 1022)) << 52;
1248 r |= m & 0xfffffffffffffU;
1249 #endif
1250
1251 return r;
1252 }
1253
1254 /* converts an ieee double/binary64 to a double */
1255 ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
1256 ecb_function_ double
1257 ecb_binary64_to_double (uint64_t x)
1258 {
1259 double r;
1260
1261 #if ECB_STDFP
1262 memcpy (&r, &x, 8);
1263 #else
1264 /* emulation, only works for normals and subnormals and +0 */
1265 int neg = x >> 63;
1266 int e = (x >> 52) & 0x7ffU;
1267
1268 x &= 0xfffffffffffffU;
1269
1270 if (e)
1271 x |= 0x10000000000000U;
1272 else
1273 e = 1;
1274
1275 /* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
1276 r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
1277
1278 r = neg ? -r : r;
1279 #endif
1280
1281 return r;
1282 }
1283
986#endif 1284#endif
987 1285
988#endif 1286#endif
989 1287
990/* ECB.H END */ 1288/* ECB.H END */
… …
1884 ev_syserr ("(libev) error creating signal/async pipe"); 2182 ev_syserr ("(libev) error creating signal/async pipe");
1885 2183
1886 fd_intern (fds [0]); 2184 fd_intern (fds [0]);
1887 } 2185 }
1888 2186
1889 fd_intern (fds [1]);
1890
1891 evpipe [0] = fds [0]; 2187 evpipe [0] = fds [0];
1892 2188
1893 if (evpipe [1] < 0) 2189 if (evpipe [1] < 0)
1894 evpipe [1] = fds [1]; /* first call, set write fd */ 2190 evpipe [1] = fds [1]; /* first call, set write fd */
1895 else 2191 else
… …
1900 /* so must not be executed on windows */ 2196 /* so must not be executed on windows */
1901 2197
1902 dup2 (fds [1], evpipe [1]); 2198 dup2 (fds [1], evpipe [1]);
1903 close (fds [1]); 2199 close (fds [1]);
1904 } 2200 }
2201
2202 fd_intern (evpipe [1]);
1905 2203
1906 ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ); 2204 ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
1907 ev_io_start (EV_A_ &pipe_w); 2205 ev_io_start (EV_A_ &pipe_w);
1908 ev_unref (EV_A); /* watcher should not keep loop alive */ 2206 ev_unref (EV_A); /* watcher should not keep loop alive */
1909 } 2207 }
… …
2028 2326
2029void 2327void
2030ev_feed_signal (int signum) EV_THROW 2328ev_feed_signal (int signum) EV_THROW
2031{ 2329{
2032#if EV_MULTIPLICITY 2330#if EV_MULTIPLICITY
2331 EV_P;
2332 ECB_MEMORY_FENCE_ACQUIRE;
2033 EV_P = signals [signum - 1].loop; 2333 EV_A = signals [signum - 1].loop;
2034 2334
2035 if (!EV_A) 2335 if (!EV_A)
2036 return; 2336 return;
2037#endif 2337#endif
2038 2338
… …
2291{ 2591{
2292 return userdata; 2592 return userdata;
2293} 2593}
2294 2594
2295void 2595void
2296ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW 2596ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW
2297{ 2597{
2298 invoke_cb = invoke_pending_cb; 2598 invoke_cb = invoke_pending_cb;
2299} 2599}
2300 2600
2301void 2601void
2302ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW 2602ev_set_loop_release_cb (EV_P_ ev_loop_callback_nothrow release, ev_loop_callback_nothrow acquire) EV_THROW
2303{ 2603{
2304 release_cb = release; 2604 release_cb = release;
2305 acquire_cb = acquire; 2605 acquire_cb = acquire;
2306} 2606}
2307#endif 2607#endif
… …
3526#if EV_MULTIPLICITY 3826#if EV_MULTIPLICITY
3527 assert (("libev: a signal must not be attached to two different loops", 3827 assert (("libev: a signal must not be attached to two different loops",
3528 !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop)); 3828 !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3529 3829
3530 signals [w->signum - 1].loop = EV_A; 3830 signals [w->signum - 1].loop = EV_A;
3831 ECB_MEMORY_FENCE_RELEASE;
3531#endif 3832#endif
3532 3833
3533 EV_FREQUENT_CHECK; 3834 EV_FREQUENT_CHECK;
3534 3835
3535#if EV_USE_SIGNALFD 3836#if EV_USE_SIGNALFD
… …
3690# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX) 3991# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3691 3992
3692static void noinline 3993static void noinline
3693infy_add (EV_P_ ev_stat *w) 3994infy_add (EV_P_ ev_stat *w)
3694{ 3995{
3695 w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD); 3996 w->wd = inotify_add_watch (fs_fd, w->path,
3997 IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
3998 | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
3999 | IN_DONT_FOLLOW | IN_MASK_ADD);
3696 4000
3697 if (w->wd >= 0) 4001 if (w->wd >= 0)
3698 { 4002 {
3699 struct statfs sfs; 4003 struct statfs sfs;
3700 4004
… …
3704 4008
3705 if (!fs_2625) 4009 if (!fs_2625)
3706 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL; 4010 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3707 else if (!statfs (w->path, &sfs) 4011 else if (!statfs (w->path, &sfs)
3708 && (sfs.f_type == 0x1373 /* devfs */ 4012 && (sfs.f_type == 0x1373 /* devfs */
4013 || sfs.f_type == 0x4006 /* fat */
4014 || sfs.f_type == 0x4d44 /* msdos */
3709 || sfs.f_type == 0xEF53 /* ext2/3 */ 4015 || sfs.f_type == 0xEF53 /* ext2/3 */
4016 || sfs.f_type == 0x72b6 /* jffs2 */
4017 || sfs.f_type == 0x858458f6 /* ramfs */
4018 || sfs.f_type == 0x5346544e /* ntfs */
3710 || sfs.f_type == 0x3153464a /* jfs */ 4019 || sfs.f_type == 0x3153464a /* jfs */
4020 || sfs.f_type == 0x9123683e /* btrfs */
3711 || sfs.f_type == 0x52654973 /* reiser3 */ 4021 || sfs.f_type == 0x52654973 /* reiser3 */
3712 || sfs.f_type == 0x01021994 /* tempfs */ 4022 || sfs.f_type == 0x01021994 /* tmpfs */
3713 || sfs.f_type == 0x58465342 /* xfs */)) 4023 || sfs.f_type == 0x58465342 /* xfs */))
3714 w->timer.repeat = 0.; /* filesystem is local, kernel new enough */ 4024 w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3715 else 4025 else
3716 w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */ 4026 w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3717 } 4027 }

Diff Legend

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