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

Comparing libev/ev.c (file contents):
Revision 1.416 by root, Mon Apr 2 20:12:16 2012 UTC vs.
Revision 1.442 by root, Thu May 31 15:47:59 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 *
… …
201# include <sys/wait.h> 201# include <sys/wait.h>
202# include <unistd.h> 202# include <unistd.h>
203#else 203#else
204# include <io.h> 204# include <io.h>
205# define WIN32_LEAN_AND_MEAN 205# define WIN32_LEAN_AND_MEAN
206# include <winsock2.h>
206# include <windows.h> 207# include <windows.h>
207# ifndef EV_SELECT_IS_WINSOCKET 208# ifndef EV_SELECT_IS_WINSOCKET
208# define EV_SELECT_IS_WINSOCKET 1 209# define EV_SELECT_IS_WINSOCKET 1
209# endif 210# endif
210# undef EV_AVOID_STDIO 211# undef EV_AVOID_STDIO
… …
359#endif 360#endif
360 361
361/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */ 362/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
362/* which makes programs even slower. might work on other unices, too. */ 363/* which makes programs even slower. might work on other unices, too. */
363#if EV_USE_CLOCK_SYSCALL 364#if EV_USE_CLOCK_SYSCALL
364# include <syscall.h> 365# include <sys/syscall.h>
365# ifdef SYS_clock_gettime 366# ifdef SYS_clock_gettime
366# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts)) 367# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
367# undef EV_USE_MONOTONIC 368# undef EV_USE_MONOTONIC
368# define EV_USE_MONOTONIC 1 369# define EV_USE_MONOTONIC 1
369# else 370# else
… …
408/* some very old inotify.h headers don't have IN_DONT_FOLLOW */ 409/* some very old inotify.h headers don't have IN_DONT_FOLLOW */
409# ifndef IN_DONT_FOLLOW 410# ifndef IN_DONT_FOLLOW
410# undef EV_USE_INOTIFY 411# undef EV_USE_INOTIFY
411# define EV_USE_INOTIFY 0 412# define EV_USE_INOTIFY 0
412# endif 413# endif
413#endif
414
415#if EV_SELECT_IS_WINSOCKET
416# include <winsock.h>
417#endif 414#endif
418 415
419#if EV_USE_EVENTFD 416#if EV_USE_EVENTFD
420/* our minimum requirement is glibc 2.7 which has the stub, but not the header */ 417/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
421# include <stdint.h> 418# include <stdint.h>
… …
507 */ 504 */
508 505
509#ifndef ECB_H 506#ifndef ECB_H
510#define ECB_H 507#define ECB_H
511 508
509/* 16 bits major, 16 bits minor */
510#define ECB_VERSION 0x00010001
511
512#ifdef _WIN32 512#ifdef _WIN32
513 typedef signed char int8_t; 513 typedef signed char int8_t;
514 typedef unsigned char uint8_t; 514 typedef unsigned char uint8_t;
515 typedef signed short int16_t; 515 typedef signed short int16_t;
516 typedef unsigned short uint16_t; 516 typedef unsigned short uint16_t;
… …
521 typedef unsigned long long uint64_t; 521 typedef unsigned long long uint64_t;
522 #else /* _MSC_VER || __BORLANDC__ */ 522 #else /* _MSC_VER || __BORLANDC__ */
523 typedef signed __int64 int64_t; 523 typedef signed __int64 int64_t;
524 typedef unsigned __int64 uint64_t; 524 typedef unsigned __int64 uint64_t;
525 #endif 525 #endif
526 #ifdef _WIN64
527 #define ECB_PTRSIZE 8
528 typedef uint64_t uintptr_t;
529 typedef int64_t intptr_t;
530 #else
531 #define ECB_PTRSIZE 4
532 typedef uint32_t uintptr_t;
533 typedef int32_t intptr_t;
534 #endif
535 typedef intptr_t ptrdiff_t;
526#else 536#else
527 #include <inttypes.h> 537 #include <inttypes.h>
538 #if UINTMAX_MAX > 0xffffffffU
539 #define ECB_PTRSIZE 8
540 #else
541 #define ECB_PTRSIZE 4
542 #endif
528#endif 543#endif
529 544
530/* many compilers define _GNUC_ to some versions but then only implement 545/* many compilers define _GNUC_ to some versions but then only implement
531 * what their idiot authors think are the "more important" extensions, 546 * what their idiot authors think are the "more important" extensions,
532 * causing enormous grief in return for some better fake benchmark numbers. 547 * causing enormous grief in return for some better fake benchmark numbers.
533 * or so. 548 * or so.
534 * we try to detect these and simply assume they are not gcc - if they have 549 * we try to detect these and simply assume they are not gcc - if they have
535 * an issue with that they should have done it right in the first place. 550 * an issue with that they should have done it right in the first place.
536 */ 551 */
537#ifndef ECB_GCC_VERSION 552#ifndef ECB_GCC_VERSION
538 #if !defined(__GNUC_MINOR__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) || defined(__llvm__) || defined(__clang__) 553 #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
539 #define ECB_GCC_VERSION(major,minor) 0 554 #define ECB_GCC_VERSION(major,minor) 0
540 #else 555 #else
541 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) 556 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
542 #endif 557 #endif
543#endif 558#endif
544 559
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)
564#define ECB_CPP11 (__cplusplus >= 201103L)
565
545/*****************************************************************************/ 566/*****************************************************************************/
546 567
547/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */ 568/* 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 */ 569/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
549 570
550#if ECB_NO_THREADS 571#if ECB_NO_THREADS
551# define ECB_NO_SMP 1 572 #define ECB_NO_SMP 1
552#endif 573#endif
553 574
554#if ECB_NO_THREADS || ECB_NO_SMP 575#if ECB_NO_SMP
555 #define ECB_MEMORY_FENCE do { } while (0) 576 #define ECB_MEMORY_FENCE do { } while (0)
556#endif 577#endif
557 578
558#ifndef ECB_MEMORY_FENCE 579#ifndef ECB_MEMORY_FENCE
559 #if ECB_GCC_VERSION(2,5) || defined(__INTEL_COMPILER) || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110 580 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
560 #if __i386 || __i386__ 581 #if __i386 || __i386__
561 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory") 582 #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 */ 583 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
563 #define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */ 584 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
564 #elif __amd64 || __amd64__ || __x86_64 || __x86_64__ 585 #elif __amd64 || __amd64__ || __x86_64 || __x86_64__
565 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory") 586 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
566 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory") 587 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
567 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */ 588 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
568 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ 589 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
569 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 590 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
570 #elif defined(__ARM_ARCH_6__ ) || defined(__ARM_ARCH_6J__ ) \ 591 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
571 || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__) 592 || 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") 593 #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__ ) \ 594 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
574 || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7R__ ) 595 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
575 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory") 596 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
576 #elif __sparc || __sparc__ 597 #elif __sparc || __sparc__
577 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad | " : : : "memory") 598 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
578 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory") 599 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
579 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore") 600 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
580 #elif defined(__s390__) || defined(__s390x__) 601 #elif defined __s390__ || defined __s390x__
581 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory") 602 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
582 #elif defined(__mips__) 603 #elif defined __mips__
583 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 604 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
605 #elif defined __alpha__
606 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
607 #elif defined __hppa__
608 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
609 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
610 #elif defined __ia64__
611 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
584 #endif 612 #endif
585 #endif 613 #endif
586#endif 614#endif
587 615
588#ifndef ECB_MEMORY_FENCE 616#ifndef ECB_MEMORY_FENCE
617 #if ECB_GCC_VERSION(4,7)
618 /* see comment below (stdatomic.h) about the C11 memory model. */
619 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
620 #elif defined __clang && __has_feature (cxx_atomic)
621 /* see comment below (stdatomic.h) about the C11 memory model. */
622 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
589 #if ECB_GCC_VERSION(4,4) || defined(__INTEL_COMPILER) || defined(__clang__) 623 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
590 #define ECB_MEMORY_FENCE __sync_synchronize () 624 #define ECB_MEMORY_FENCE __sync_synchronize ()
591 /*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */
592 /*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */
593 #elif _MSC_VER >= 1400 /* VC++ 2005 */ 625 #elif _MSC_VER >= 1400 /* VC++ 2005 */
594 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier) 626 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
595 #define ECB_MEMORY_FENCE _ReadWriteBarrier () 627 #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
596 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */ 628 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
597 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier () 629 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
598 #elif defined(_WIN32) 630 #elif defined _WIN32
599 #include <WinNT.h> 631 #include <WinNT.h>
600 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */ 632 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
601 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110 633 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
602 #include <mbarrier.h> 634 #include <mbarrier.h>
603 #define ECB_MEMORY_FENCE __machine_rw_barrier () 635 #define ECB_MEMORY_FENCE __machine_rw_barrier ()
604 #define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier () 636 #define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()
605 #define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier () 637 #define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()
606 #elif __xlC__ 638 #elif __xlC__
607 #define ECB_MEMORY_FENCE __sync () 639 #define ECB_MEMORY_FENCE __sync ()
640 #endif
641#endif
642
643#ifndef ECB_MEMORY_FENCE
644 #if ECB_C11 && !defined __STDC_NO_ATOMICS__
645 /* we assume that these memory fences work on all variables/all memory accesses, */
646 /* not just C11 atomics and atomic accesses */
647 #include <stdatomic.h>
648 /* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
649 /* 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 */
651 /* for most usages, or gcc and clang have a bug */
652 /* I *currently* lean towards the latter, and inefficiently implement */
653 /* all three of ecb's fences as a seq_cst fence */
654 #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
608 #endif 655 #endif
609#endif 656#endif
610 657
611#ifndef ECB_MEMORY_FENCE 658#ifndef ECB_MEMORY_FENCE
612 #if !ECB_AVOID_PTHREADS 659 #if !ECB_AVOID_PTHREADS
… …
624 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER; 671 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
625 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0) 672 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
626 #endif 673 #endif
627#endif 674#endif
628 675
629#if !defined(ECB_MEMORY_FENCE_ACQUIRE) && defined(ECB_MEMORY_FENCE) 676#if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
630 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE 677 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
631#endif 678#endif
632 679
633#if !defined(ECB_MEMORY_FENCE_RELEASE) && defined(ECB_MEMORY_FENCE) 680#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
634 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE 681 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
635#endif 682#endif
636 683
637/*****************************************************************************/ 684/*****************************************************************************/
638
639#define ECB_C99 (__STDC_VERSION__ >= 199901L)
640 685
641#if __cplusplus 686#if __cplusplus
642 #define ecb_inline static inline 687 #define ecb_inline static inline
643#elif ECB_GCC_VERSION(2,5) 688#elif ECB_GCC_VERSION(2,5)
644 #define ecb_inline static __inline__ 689 #define ecb_inline static __inline__
… …
683#elif ECB_GCC_VERSION(3,0) 728#elif ECB_GCC_VERSION(3,0)
684 #define ecb_decltype(x) __typeof(x) 729 #define ecb_decltype(x) __typeof(x)
685#endif 730#endif
686 731
687#define ecb_noinline ecb_attribute ((__noinline__)) 732#define ecb_noinline ecb_attribute ((__noinline__))
688#define ecb_noreturn ecb_attribute ((__noreturn__))
689#define ecb_unused ecb_attribute ((__unused__)) 733#define ecb_unused ecb_attribute ((__unused__))
690#define ecb_const ecb_attribute ((__const__)) 734#define ecb_const ecb_attribute ((__const__))
691#define ecb_pure ecb_attribute ((__pure__)) 735#define ecb_pure ecb_attribute ((__pure__))
736
737#if ECB_C11
738 #define ecb_noreturn _Noreturn
739#else
740 #define ecb_noreturn ecb_attribute ((__noreturn__))
741#endif
692 742
693#if ECB_GCC_VERSION(4,3) 743#if ECB_GCC_VERSION(4,3)
694 #define ecb_artificial ecb_attribute ((__artificial__)) 744 #define ecb_artificial ecb_attribute ((__artificial__))
695 #define ecb_hot ecb_attribute ((__hot__)) 745 #define ecb_hot ecb_attribute ((__hot__))
696 #define ecb_cold ecb_attribute ((__cold__)) 746 #define ecb_cold ecb_attribute ((__cold__))
… …
787 837
788 return r + ecb_ld32 (x); 838 return r + ecb_ld32 (x);
789 } 839 }
790#endif 840#endif
791 841
842ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) ecb_const;
843ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
844ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) ecb_const;
845ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
846
792ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const; 847ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;
793ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) 848ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)
794{ 849{
795 return ( (x * 0x0802U & 0x22110U) 850 return ( (x * 0x0802U & 0x22110U)
796 | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16; 851 | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
… …
1103{ 1158{
1104 write (STDERR_FILENO, msg, strlen (msg)); 1159 write (STDERR_FILENO, msg, strlen (msg));
1105} 1160}
1106#endif 1161#endif
1107 1162
1108static void (*syserr_cb)(const char *msg); 1163static void (*syserr_cb)(const char *msg) EV_THROW;
1109 1164
1110void ecb_cold 1165void ecb_cold
1111ev_set_syserr_cb (void (*cb)(const char *msg)) 1166ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW
1112{ 1167{
1113 syserr_cb = cb; 1168 syserr_cb = cb;
1114} 1169}
1115 1170
1116static void noinline ecb_cold 1171static void noinline ecb_cold
… …
1134 abort (); 1189 abort ();
1135 } 1190 }
1136} 1191}
1137 1192
1138static void * 1193static void *
1139ev_realloc_emul (void *ptr, long size) 1194ev_realloc_emul (void *ptr, long size) EV_THROW
1140{ 1195{
1141#if __GLIBC__ 1196#if __GLIBC__
1142 return realloc (ptr, size); 1197 return realloc (ptr, size);
1143#else 1198#else
1144 /* some systems, notably openbsd and darwin, fail to properly 1199 /* some systems, notably openbsd and darwin, fail to properly
… …
1152 free (ptr); 1207 free (ptr);
1153 return 0; 1208 return 0;
1154#endif 1209#endif
1155} 1210}
1156 1211
1157static void *(*alloc)(void *ptr, long size) = ev_realloc_emul; 1212static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1158 1213
1159void ecb_cold 1214void ecb_cold
1160ev_set_allocator (void *(*cb)(void *ptr, long size)) 1215ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW
1161{ 1216{
1162 alloc = cb; 1217 alloc = cb;
1163} 1218}
1164 1219
1165inline_speed void * 1220inline_speed void *
… …
1282 1337
1283/*****************************************************************************/ 1338/*****************************************************************************/
1284 1339
1285#ifndef EV_HAVE_EV_TIME 1340#ifndef EV_HAVE_EV_TIME
1286ev_tstamp 1341ev_tstamp
1287ev_time (void) 1342ev_time (void) EV_THROW
1288{ 1343{
1289#if EV_USE_REALTIME 1344#if EV_USE_REALTIME
1290 if (expect_true (have_realtime)) 1345 if (expect_true (have_realtime))
1291 { 1346 {
1292 struct timespec ts; 1347 struct timespec ts;
… …
1316 return ev_time (); 1371 return ev_time ();
1317} 1372}
1318 1373
1319#if EV_MULTIPLICITY 1374#if EV_MULTIPLICITY
1320ev_tstamp 1375ev_tstamp
1321ev_now (EV_P) 1376ev_now (EV_P) EV_THROW
1322{ 1377{
1323 return ev_rt_now; 1378 return ev_rt_now;
1324} 1379}
1325#endif 1380#endif
1326 1381
1327void 1382void
1328ev_sleep (ev_tstamp delay) 1383ev_sleep (ev_tstamp delay) EV_THROW
1329{ 1384{
1330 if (delay > 0.) 1385 if (delay > 0.)
1331 { 1386 {
1332#if EV_USE_NANOSLEEP 1387#if EV_USE_NANOSLEEP
1333 struct timespec ts; 1388 struct timespec ts;
… …
1414pendingcb (EV_P_ ev_prepare *w, int revents) 1469pendingcb (EV_P_ ev_prepare *w, int revents)
1415{ 1470{
1416} 1471}
1417 1472
1418void noinline 1473void noinline
1419ev_feed_event (EV_P_ void *w, int revents) 1474ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1420{ 1475{
1421 W w_ = (W)w; 1476 W w_ = (W)w;
1422 int pri = ABSPRI (w_); 1477 int pri = ABSPRI (w_);
1423 1478
1424 if (expect_false (w_->pending)) 1479 if (expect_false (w_->pending))
… …
1428 w_->pending = ++pendingcnt [pri]; 1483 w_->pending = ++pendingcnt [pri];
1429 array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2); 1484 array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
1430 pendings [pri][w_->pending - 1].w = w_; 1485 pendings [pri][w_->pending - 1].w = w_;
1431 pendings [pri][w_->pending - 1].events = revents; 1486 pendings [pri][w_->pending - 1].events = revents;
1432 } 1487 }
1488
1489 pendingpri = NUMPRI - 1;
1433} 1490}
1434 1491
1435inline_speed void 1492inline_speed void
1436feed_reverse (EV_P_ W w) 1493feed_reverse (EV_P_ W w)
1437{ 1494{
… …
1483 if (expect_true (!anfd->reify)) 1540 if (expect_true (!anfd->reify))
1484 fd_event_nocheck (EV_A_ fd, revents); 1541 fd_event_nocheck (EV_A_ fd, revents);
1485} 1542}
1486 1543
1487void 1544void
1488ev_feed_fd_event (EV_P_ int fd, int revents) 1545ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
1489{ 1546{
1490 if (fd >= 0 && fd < anfdmax) 1547 if (fd >= 0 && fd < anfdmax)
1491 fd_event_nocheck (EV_A_ fd, revents); 1548 fd_event_nocheck (EV_A_ fd, revents);
1492} 1549}
1493 1550
… …
1842} 1899}
1843 1900
1844inline_speed void 1901inline_speed void
1845evpipe_write (EV_P_ EV_ATOMIC_T *flag) 1902evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1846{ 1903{
1904 ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
1905
1847 if (expect_true (*flag)) 1906 if (expect_true (*flag))
1848 return; 1907 return;
1849 1908
1850 *flag = 1; 1909 *flag = 1;
1851
1852 ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */ 1910 ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
1853 1911
1854 pipe_write_skipped = 1; 1912 pipe_write_skipped = 1;
1855 1913
1856 ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */ 1914 ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
1857 1915
1858 if (pipe_write_wanted) 1916 if (pipe_write_wanted)
1859 { 1917 {
1860 int old_errno; 1918 int old_errno;
1861 1919
1862 pipe_write_skipped = 0; /* just an optimisation, no fence needed */ 1920 pipe_write_skipped = 0;
1921 ECB_MEMORY_FENCE_RELEASE;
1863 1922
1864 old_errno = errno; /* save errno because write will clobber it */ 1923 old_errno = errno; /* save errno because write will clobber it */
1865 1924
1866#if EV_USE_EVENTFD 1925#if EV_USE_EVENTFD
1867 if (evfd >= 0) 1926 if (evfd >= 0)
… …
1870 write (evfd, &counter, sizeof (uint64_t)); 1929 write (evfd, &counter, sizeof (uint64_t));
1871 } 1930 }
1872 else 1931 else
1873#endif 1932#endif
1874 { 1933 {
1875 /* win32 people keep sending patches that change this write() to send() */ 1934#ifdef _WIN32
1876 /* and then run away. but send() is wrong, it wants a socket handle on win32 */ 1935 WSABUF buf;
1877 /* so when you think this write should be a send instead, please find out */ 1936 DWORD sent;
1878 /* where your send() is from - it's definitely not the microsoft send, and */ 1937 buf.buf = &buf;
1879 /* tell me. thank you. */ 1938 buf.len = 1;
1880 /* it might be that your problem is that your environment needs EV_USE_WSASOCKET */ 1939 WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
1881 /* check the ev documentation on how to use this flag */ 1940#else
1882 write (evpipe [1], &(evpipe [1]), 1); 1941 write (evpipe [1], &(evpipe [1]), 1);
1942#endif
1883 } 1943 }
1884 1944
1885 errno = old_errno; 1945 errno = old_errno;
1886 } 1946 }
1887} 1947}
… …
1902 read (evfd, &counter, sizeof (uint64_t)); 1962 read (evfd, &counter, sizeof (uint64_t));
1903 } 1963 }
1904 else 1964 else
1905#endif 1965#endif
1906 { 1966 {
1907 char dummy; 1967 char dummy[4];
1908 /* see discussion in evpipe_write when you think this read should be recv in win32 */ 1968#ifdef _WIN32
1969 WSABUF buf;
1970 DWORD recvd;
1971 DWORD flags = 0;
1972 buf.buf = dummy;
1973 buf.len = sizeof (dummy);
1974 WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, &flags, 0, 0);
1975#else
1909 read (evpipe [0], &dummy, 1); 1976 read (evpipe [0], &dummy, sizeof (dummy));
1977#endif
1910 } 1978 }
1911 } 1979 }
1912 1980
1913 pipe_write_skipped = 0; 1981 pipe_write_skipped = 0;
1982
1983 ECB_MEMORY_FENCE; /* push out skipped, acquire flags */
1914 1984
1915#if EV_SIGNAL_ENABLE 1985#if EV_SIGNAL_ENABLE
1916 if (sig_pending) 1986 if (sig_pending)
1917 { 1987 {
1918 sig_pending = 0; 1988 sig_pending = 0;
1989
1990 ECB_MEMORY_FENCE;
1919 1991
1920 for (i = EV_NSIG - 1; i--; ) 1992 for (i = EV_NSIG - 1; i--; )
1921 if (expect_false (signals [i].pending)) 1993 if (expect_false (signals [i].pending))
1922 ev_feed_signal_event (EV_A_ i + 1); 1994 ev_feed_signal_event (EV_A_ i + 1);
1923 } 1995 }
… …
1925 1997
1926#if EV_ASYNC_ENABLE 1998#if EV_ASYNC_ENABLE
1927 if (async_pending) 1999 if (async_pending)
1928 { 2000 {
1929 async_pending = 0; 2001 async_pending = 0;
2002
2003 ECB_MEMORY_FENCE;
1930 2004
1931 for (i = asynccnt; i--; ) 2005 for (i = asynccnt; i--; )
1932 if (asyncs [i]->sent) 2006 if (asyncs [i]->sent)
1933 { 2007 {
1934 asyncs [i]->sent = 0; 2008 asyncs [i]->sent = 0;
2009 ECB_MEMORY_FENCE_RELEASE;
1935 ev_feed_event (EV_A_ asyncs [i], EV_ASYNC); 2010 ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
1936 } 2011 }
1937 } 2012 }
1938#endif 2013#endif
1939} 2014}
1940 2015
1941/*****************************************************************************/ 2016/*****************************************************************************/
1942 2017
1943void 2018void
1944ev_feed_signal (int signum) 2019ev_feed_signal (int signum) EV_THROW
1945{ 2020{
1946#if EV_MULTIPLICITY 2021#if EV_MULTIPLICITY
1947 EV_P = signals [signum - 1].loop; 2022 EV_P = signals [signum - 1].loop;
1948 2023
1949 if (!EV_A) 2024 if (!EV_A)
… …
1966 2041
1967 ev_feed_signal (signum); 2042 ev_feed_signal (signum);
1968} 2043}
1969 2044
1970void noinline 2045void noinline
1971ev_feed_signal_event (EV_P_ int signum) 2046ev_feed_signal_event (EV_P_ int signum) EV_THROW
1972{ 2047{
1973 WL w; 2048 WL w;
1974 2049
1975 if (expect_false (signum <= 0 || signum > EV_NSIG)) 2050 if (expect_false (signum <= 0 || signum > EV_NSIG))
1976 return; 2051 return;
… …
1984 if (expect_false (signals [signum].loop != EV_A)) 2059 if (expect_false (signals [signum].loop != EV_A))
1985 return; 2060 return;
1986#endif 2061#endif
1987 2062
1988 signals [signum].pending = 0; 2063 signals [signum].pending = 0;
2064 ECB_MEMORY_FENCE_RELEASE;
1989 2065
1990 for (w = signals [signum].head; w; w = w->next) 2066 for (w = signals [signum].head; w; w = w->next)
1991 ev_feed_event (EV_A_ (W)w, EV_SIGNAL); 2067 ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
1992} 2068}
1993 2069
… …
2092#if EV_USE_SELECT 2168#if EV_USE_SELECT
2093# include "ev_select.c" 2169# include "ev_select.c"
2094#endif 2170#endif
2095 2171
2096int ecb_cold 2172int ecb_cold
2097ev_version_major (void) 2173ev_version_major (void) EV_THROW
2098{ 2174{
2099 return EV_VERSION_MAJOR; 2175 return EV_VERSION_MAJOR;
2100} 2176}
2101 2177
2102int ecb_cold 2178int ecb_cold
2103ev_version_minor (void) 2179ev_version_minor (void) EV_THROW
2104{ 2180{
2105 return EV_VERSION_MINOR; 2181 return EV_VERSION_MINOR;
2106} 2182}
2107 2183
2108/* return true if we are running with elevated privileges and should ignore env variables */ 2184/* return true if we are running with elevated privileges and should ignore env variables */
… …
2116 || getgid () != getegid (); 2192 || getgid () != getegid ();
2117#endif 2193#endif
2118} 2194}
2119 2195
2120unsigned int ecb_cold 2196unsigned int ecb_cold
2121ev_supported_backends (void) 2197ev_supported_backends (void) EV_THROW
2122{ 2198{
2123 unsigned int flags = 0; 2199 unsigned int flags = 0;
2124 2200
2125 if (EV_USE_PORT ) flags |= EVBACKEND_PORT; 2201 if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2126 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE; 2202 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
… …
2130 2206
2131 return flags; 2207 return flags;
2132} 2208}
2133 2209
2134unsigned int ecb_cold 2210unsigned int ecb_cold
2135ev_recommended_backends (void) 2211ev_recommended_backends (void) EV_THROW
2136{ 2212{
2137 unsigned int flags = ev_supported_backends (); 2213 unsigned int flags = ev_supported_backends ();
2138 2214
2139#ifndef __NetBSD__ 2215#ifndef __NetBSD__
2140 /* kqueue is borked on everything but netbsd apparently */ 2216 /* kqueue is borked on everything but netbsd apparently */
… …
2152 2228
2153 return flags; 2229 return flags;
2154} 2230}
2155 2231
2156unsigned int ecb_cold 2232unsigned int ecb_cold
2157ev_embeddable_backends (void) 2233ev_embeddable_backends (void) EV_THROW
2158{ 2234{
2159 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT; 2235 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2160 2236
2161 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */ 2237 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2162 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */ 2238 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
… …
2164 2240
2165 return flags; 2241 return flags;
2166} 2242}
2167 2243
2168unsigned int 2244unsigned int
2169ev_backend (EV_P) 2245ev_backend (EV_P) EV_THROW
2170{ 2246{
2171 return backend; 2247 return backend;
2172} 2248}
2173 2249
2174#if EV_FEATURE_API 2250#if EV_FEATURE_API
2175unsigned int 2251unsigned int
2176ev_iteration (EV_P) 2252ev_iteration (EV_P) EV_THROW
2177{ 2253{
2178 return loop_count; 2254 return loop_count;
2179} 2255}
2180 2256
2181unsigned int 2257unsigned int
2182ev_depth (EV_P) 2258ev_depth (EV_P) EV_THROW
2183{ 2259{
2184 return loop_depth; 2260 return loop_depth;
2185} 2261}
2186 2262
2187void 2263void
2188ev_set_io_collect_interval (EV_P_ ev_tstamp interval) 2264ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2189{ 2265{
2190 io_blocktime = interval; 2266 io_blocktime = interval;
2191} 2267}
2192 2268
2193void 2269void
2194ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) 2270ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2195{ 2271{
2196 timeout_blocktime = interval; 2272 timeout_blocktime = interval;
2197} 2273}
2198 2274
2199void 2275void
2200ev_set_userdata (EV_P_ void *data) 2276ev_set_userdata (EV_P_ void *data) EV_THROW
2201{ 2277{
2202 userdata = data; 2278 userdata = data;
2203} 2279}
2204 2280
2205void * 2281void *
2206ev_userdata (EV_P) 2282ev_userdata (EV_P) EV_THROW
2207{ 2283{
2208 return userdata; 2284 return userdata;
2209} 2285}
2210 2286
2211void 2287void
2212ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) 2288ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
2213{ 2289{
2214 invoke_cb = invoke_pending_cb; 2290 invoke_cb = invoke_pending_cb;
2215} 2291}
2216 2292
2217void 2293void
2218ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) 2294ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW
2219{ 2295{
2220 release_cb = release; 2296 release_cb = release;
2221 acquire_cb = acquire; 2297 acquire_cb = acquire;
2222} 2298}
2223#endif 2299#endif
2224 2300
2225/* initialise a loop structure, must be zero-initialised */ 2301/* initialise a loop structure, must be zero-initialised */
2226static void noinline ecb_cold 2302static void noinline ecb_cold
2227loop_init (EV_P_ unsigned int flags) 2303loop_init (EV_P_ unsigned int flags) EV_THROW
2228{ 2304{
2229 if (!backend) 2305 if (!backend)
2230 { 2306 {
2231 origflags = flags; 2307 origflags = flags;
2232 2308
… …
2337 EV_INVOKE_PENDING; 2413 EV_INVOKE_PENDING;
2338 } 2414 }
2339#endif 2415#endif
2340 2416
2341#if EV_CHILD_ENABLE 2417#if EV_CHILD_ENABLE
2342 if (ev_is_active (&childev)) 2418 if (ev_is_default_loop (EV_A) && ev_is_active (&childev))
2343 { 2419 {
2344 ev_ref (EV_A); /* child watcher */ 2420 ev_ref (EV_A); /* child watcher */
2345 ev_signal_stop (EV_A_ &childev); 2421 ev_signal_stop (EV_A_ &childev);
2346 } 2422 }
2347#endif 2423#endif
… …
2485} 2561}
2486 2562
2487#if EV_MULTIPLICITY 2563#if EV_MULTIPLICITY
2488 2564
2489struct ev_loop * ecb_cold 2565struct ev_loop * ecb_cold
2490ev_loop_new (unsigned int flags) 2566ev_loop_new (unsigned int flags) EV_THROW
2491{ 2567{
2492 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop)); 2568 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2493 2569
2494 memset (EV_A, 0, sizeof (struct ev_loop)); 2570 memset (EV_A, 0, sizeof (struct ev_loop));
2495 loop_init (EV_A_ flags); 2571 loop_init (EV_A_ flags);
… …
2539} 2615}
2540#endif 2616#endif
2541 2617
2542#if EV_FEATURE_API 2618#if EV_FEATURE_API
2543void ecb_cold 2619void ecb_cold
2544ev_verify (EV_P) 2620ev_verify (EV_P) EV_THROW
2545{ 2621{
2546#if EV_VERIFY 2622#if EV_VERIFY
2547 int i; 2623 int i;
2548 WL w; 2624 WL w, w2;
2549 2625
2550 assert (activecnt >= -1); 2626 assert (activecnt >= -1);
2551 2627
2552 assert (fdchangemax >= fdchangecnt); 2628 assert (fdchangemax >= fdchangecnt);
2553 for (i = 0; i < fdchangecnt; ++i) 2629 for (i = 0; i < fdchangecnt; ++i)
2554 assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0)); 2630 assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0));
2555 2631
2556 assert (anfdmax >= 0); 2632 assert (anfdmax >= 0);
2557 for (i = 0; i < anfdmax; ++i) 2633 for (i = 0; i < anfdmax; ++i)
2634 {
2635 int j = 0;
2636
2558 for (w = anfds [i].head; w; w = w->next) 2637 for (w = w2 = anfds [i].head; w; w = w->next)
2559 { 2638 {
2560 verify_watcher (EV_A_ (W)w); 2639 verify_watcher (EV_A_ (W)w);
2640
2641 if (j++ & 1)
2642 {
2643 assert (("libev: io watcher list contains a loop", w != w2));
2644 w2 = w2->next;
2645 }
2646
2561 assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1)); 2647 assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1));
2562 assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i)); 2648 assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
2563 } 2649 }
2650 }
2564 2651
2565 assert (timermax >= timercnt); 2652 assert (timermax >= timercnt);
2566 verify_heap (EV_A_ timers, timercnt); 2653 verify_heap (EV_A_ timers, timercnt);
2567 2654
2568#if EV_PERIODIC_ENABLE 2655#if EV_PERIODIC_ENABLE
… …
2618#if EV_MULTIPLICITY 2705#if EV_MULTIPLICITY
2619struct ev_loop * ecb_cold 2706struct ev_loop * ecb_cold
2620#else 2707#else
2621int 2708int
2622#endif 2709#endif
2623ev_default_loop (unsigned int flags) 2710ev_default_loop (unsigned int flags) EV_THROW
2624{ 2711{
2625 if (!ev_default_loop_ptr) 2712 if (!ev_default_loop_ptr)
2626 { 2713 {
2627#if EV_MULTIPLICITY 2714#if EV_MULTIPLICITY
2628 EV_P = ev_default_loop_ptr = &default_loop_struct; 2715 EV_P = ev_default_loop_ptr = &default_loop_struct;
… …
2647 2734
2648 return ev_default_loop_ptr; 2735 return ev_default_loop_ptr;
2649} 2736}
2650 2737
2651void 2738void
2652ev_loop_fork (EV_P) 2739ev_loop_fork (EV_P) EV_THROW
2653{ 2740{
2654 postfork = 1; /* must be in line with ev_default_fork */ 2741 postfork = 1;
2655} 2742}
2656 2743
2657/*****************************************************************************/ 2744/*****************************************************************************/
2658 2745
2659void 2746void
… …
2661{ 2748{
2662 EV_CB_INVOKE ((W)w, revents); 2749 EV_CB_INVOKE ((W)w, revents);
2663} 2750}
2664 2751
2665unsigned int 2752unsigned int
2666ev_pending_count (EV_P) 2753ev_pending_count (EV_P) EV_THROW
2667{ 2754{
2668 int pri; 2755 int pri;
2669 unsigned int count = 0; 2756 unsigned int count = 0;
2670 2757
2671 for (pri = NUMPRI; pri--; ) 2758 for (pri = NUMPRI; pri--; )
… …
2675} 2762}
2676 2763
2677void noinline 2764void noinline
2678ev_invoke_pending (EV_P) 2765ev_invoke_pending (EV_P)
2679{ 2766{
2680 int pri; 2767 for (pendingpri = NUMPRI; pendingpri--; ) /* pendingpri is modified during the loop */
2681
2682 for (pri = NUMPRI; pri--; )
2683 while (pendingcnt [pri]) 2768 while (pendingcnt [pendingpri])
2684 { 2769 {
2685 ANPENDING *p = pendings [pri] + --pendingcnt [pri]; 2770 ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2686 2771
2687 p->w->pending = 0; 2772 p->w->pending = 0;
2688 EV_CB_INVOKE (p->w, p->events); 2773 EV_CB_INVOKE (p->w, p->events);
2689 EV_FREQUENT_CHECK; 2774 EV_FREQUENT_CHECK;
2690 } 2775 }
… …
2785{ 2870{
2786 EV_FREQUENT_CHECK; 2871 EV_FREQUENT_CHECK;
2787 2872
2788 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now) 2873 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
2789 { 2874 {
2790 int feed_count = 0;
2791
2792 do 2875 do
2793 { 2876 {
2794 ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]); 2877 ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
2795 2878
2796 /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/ 2879 /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/
… …
2930 3013
2931 mn_now = ev_rt_now; 3014 mn_now = ev_rt_now;
2932 } 3015 }
2933} 3016}
2934 3017
2935void 3018int
2936ev_run (EV_P_ int flags) 3019ev_run (EV_P_ int flags)
2937{ 3020{
2938#if EV_FEATURE_API 3021#if EV_FEATURE_API
2939 ++loop_depth; 3022 ++loop_depth;
2940#endif 3023#endif
… …
3055 backend_poll (EV_A_ waittime); 3138 backend_poll (EV_A_ waittime);
3056 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */ 3139 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
3057 3140
3058 pipe_write_wanted = 0; /* just an optimisation, no fence needed */ 3141 pipe_write_wanted = 0; /* just an optimisation, no fence needed */
3059 3142
3143 ECB_MEMORY_FENCE_ACQUIRE;
3060 if (pipe_write_skipped) 3144 if (pipe_write_skipped)
3061 { 3145 {
3062 assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w))); 3146 assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3063 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM); 3147 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3064 } 3148 }
… …
3097 loop_done = EVBREAK_CANCEL; 3181 loop_done = EVBREAK_CANCEL;
3098 3182
3099#if EV_FEATURE_API 3183#if EV_FEATURE_API
3100 --loop_depth; 3184 --loop_depth;
3101#endif 3185#endif
3186
3187 return activecnt;
3102} 3188}
3103 3189
3104void 3190void
3105ev_break (EV_P_ int how) 3191ev_break (EV_P_ int how) EV_THROW
3106{ 3192{
3107 loop_done = how; 3193 loop_done = how;
3108} 3194}
3109 3195
3110void 3196void
3111ev_ref (EV_P) 3197ev_ref (EV_P) EV_THROW
3112{ 3198{
3113 ++activecnt; 3199 ++activecnt;
3114} 3200}
3115 3201
3116void 3202void
3117ev_unref (EV_P) 3203ev_unref (EV_P) EV_THROW
3118{ 3204{
3119 --activecnt; 3205 --activecnt;
3120} 3206}
3121 3207
3122void 3208void
3123ev_now_update (EV_P) 3209ev_now_update (EV_P) EV_THROW
3124{ 3210{
3125 time_update (EV_A_ 1e100); 3211 time_update (EV_A_ 1e100);
3126} 3212}
3127 3213
3128void 3214void
3129ev_suspend (EV_P) 3215ev_suspend (EV_P) EV_THROW
3130{ 3216{
3131 ev_now_update (EV_A); 3217 ev_now_update (EV_A);
3132} 3218}
3133 3219
3134void 3220void
3135ev_resume (EV_P) 3221ev_resume (EV_P) EV_THROW
3136{ 3222{
3137 ev_tstamp mn_prev = mn_now; 3223 ev_tstamp mn_prev = mn_now;
3138 3224
3139 ev_now_update (EV_A); 3225 ev_now_update (EV_A);
3140 timers_reschedule (EV_A_ mn_now - mn_prev); 3226 timers_reschedule (EV_A_ mn_now - mn_prev);
… …
3179 w->pending = 0; 3265 w->pending = 0;
3180 } 3266 }
3181} 3267}
3182 3268
3183int 3269int
3184ev_clear_pending (EV_P_ void *w) 3270ev_clear_pending (EV_P_ void *w) EV_THROW
3185{ 3271{
3186 W w_ = (W)w; 3272 W w_ = (W)w;
3187 int pending = w_->pending; 3273 int pending = w_->pending;
3188 3274
3189 if (expect_true (pending)) 3275 if (expect_true (pending))
… …
3222} 3308}
3223 3309
3224/*****************************************************************************/ 3310/*****************************************************************************/
3225 3311
3226void noinline 3312void noinline
3227ev_io_start (EV_P_ ev_io *w) 3313ev_io_start (EV_P_ ev_io *w) EV_THROW
3228{ 3314{
3229 int fd = w->fd; 3315 int fd = w->fd;
3230 3316
3231 if (expect_false (ev_is_active (w))) 3317 if (expect_false (ev_is_active (w)))
3232 return; 3318 return;
… …
3238 3324
3239 ev_start (EV_A_ (W)w, 1); 3325 ev_start (EV_A_ (W)w, 1);
3240 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); 3326 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
3241 wlist_add (&anfds[fd].head, (WL)w); 3327 wlist_add (&anfds[fd].head, (WL)w);
3242 3328
3329 /* common bug, apparently */
3330 assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3331
3243 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY); 3332 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
3244 w->events &= ~EV__IOFDSET; 3333 w->events &= ~EV__IOFDSET;
3245 3334
3246 EV_FREQUENT_CHECK; 3335 EV_FREQUENT_CHECK;
3247} 3336}
3248 3337
3249void noinline 3338void noinline
3250ev_io_stop (EV_P_ ev_io *w) 3339ev_io_stop (EV_P_ ev_io *w) EV_THROW
3251{ 3340{
3252 clear_pending (EV_A_ (W)w); 3341 clear_pending (EV_A_ (W)w);
3253 if (expect_false (!ev_is_active (w))) 3342 if (expect_false (!ev_is_active (w)))
3254 return; 3343 return;
3255 3344
… …
3264 3353
3265 EV_FREQUENT_CHECK; 3354 EV_FREQUENT_CHECK;
3266} 3355}
3267 3356
3268void noinline 3357void noinline
3269ev_timer_start (EV_P_ ev_timer *w) 3358ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3270{ 3359{
3271 if (expect_false (ev_is_active (w))) 3360 if (expect_false (ev_is_active (w)))
3272 return; 3361 return;
3273 3362
3274 ev_at (w) += mn_now; 3363 ev_at (w) += mn_now;
… …
3288 3377
3289 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/ 3378 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3290} 3379}
3291 3380
3292void noinline 3381void noinline
3293ev_timer_stop (EV_P_ ev_timer *w) 3382ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3294{ 3383{
3295 clear_pending (EV_A_ (W)w); 3384 clear_pending (EV_A_ (W)w);
3296 if (expect_false (!ev_is_active (w))) 3385 if (expect_false (!ev_is_active (w)))
3297 return; 3386 return;
3298 3387
… …
3318 3407
3319 EV_FREQUENT_CHECK; 3408 EV_FREQUENT_CHECK;
3320} 3409}
3321 3410
3322void noinline 3411void noinline
3323ev_timer_again (EV_P_ ev_timer *w) 3412ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3324{ 3413{
3325 EV_FREQUENT_CHECK; 3414 EV_FREQUENT_CHECK;
3326 3415
3327 clear_pending (EV_A_ (W)w); 3416 clear_pending (EV_A_ (W)w);
3328 3417
… …
3345 3434
3346 EV_FREQUENT_CHECK; 3435 EV_FREQUENT_CHECK;
3347} 3436}
3348 3437
3349ev_tstamp 3438ev_tstamp
3350ev_timer_remaining (EV_P_ ev_timer *w) 3439ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
3351{ 3440{
3352 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); 3441 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3353} 3442}
3354 3443
3355#if EV_PERIODIC_ENABLE 3444#if EV_PERIODIC_ENABLE
3356void noinline 3445void noinline
3357ev_periodic_start (EV_P_ ev_periodic *w) 3446ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3358{ 3447{
3359 if (expect_false (ev_is_active (w))) 3448 if (expect_false (ev_is_active (w)))
3360 return; 3449 return;
3361 3450
3362 if (w->reschedule_cb) 3451 if (w->reschedule_cb)
… …
3382 3471
3383 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/ 3472 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3384} 3473}
3385 3474
3386void noinline 3475void noinline
3387ev_periodic_stop (EV_P_ ev_periodic *w) 3476ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3388{ 3477{
3389 clear_pending (EV_A_ (W)w); 3478 clear_pending (EV_A_ (W)w);
3390 if (expect_false (!ev_is_active (w))) 3479 if (expect_false (!ev_is_active (w)))
3391 return; 3480 return;
3392 3481
… …
3410 3499
3411 EV_FREQUENT_CHECK; 3500 EV_FREQUENT_CHECK;
3412} 3501}
3413 3502
3414void noinline 3503void noinline
3415ev_periodic_again (EV_P_ ev_periodic *w) 3504ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3416{ 3505{
3417 /* TODO: use adjustheap and recalculation */ 3506 /* TODO: use adjustheap and recalculation */
3418 ev_periodic_stop (EV_A_ w); 3507 ev_periodic_stop (EV_A_ w);
3419 ev_periodic_start (EV_A_ w); 3508 ev_periodic_start (EV_A_ w);
3420} 3509}
… …
3425#endif 3514#endif
3426 3515
3427#if EV_SIGNAL_ENABLE 3516#if EV_SIGNAL_ENABLE
3428 3517
3429void noinline 3518void noinline
3430ev_signal_start (EV_P_ ev_signal *w) 3519ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3431{ 3520{
3432 if (expect_false (ev_is_active (w))) 3521 if (expect_false (ev_is_active (w)))
3433 return; 3522 return;
3434 3523
3435 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG)); 3524 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
… …
3506 3595
3507 EV_FREQUENT_CHECK; 3596 EV_FREQUENT_CHECK;
3508} 3597}
3509 3598
3510void noinline 3599void noinline
3511ev_signal_stop (EV_P_ ev_signal *w) 3600ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3512{ 3601{
3513 clear_pending (EV_A_ (W)w); 3602 clear_pending (EV_A_ (W)w);
3514 if (expect_false (!ev_is_active (w))) 3603 if (expect_false (!ev_is_active (w)))
3515 return; 3604 return;
3516 3605
… …
3547#endif 3636#endif
3548 3637
3549#if EV_CHILD_ENABLE 3638#if EV_CHILD_ENABLE
3550 3639
3551void 3640void
3552ev_child_start (EV_P_ ev_child *w) 3641ev_child_start (EV_P_ ev_child *w) EV_THROW
3553{ 3642{
3554#if EV_MULTIPLICITY 3643#if EV_MULTIPLICITY
3555 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); 3644 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3556#endif 3645#endif
3557 if (expect_false (ev_is_active (w))) 3646 if (expect_false (ev_is_active (w)))
… …
3564 3653
3565 EV_FREQUENT_CHECK; 3654 EV_FREQUENT_CHECK;
3566} 3655}
3567 3656
3568void 3657void
3569ev_child_stop (EV_P_ ev_child *w) 3658ev_child_stop (EV_P_ ev_child *w) EV_THROW
3570{ 3659{
3571 clear_pending (EV_A_ (W)w); 3660 clear_pending (EV_A_ (W)w);
3572 if (expect_false (!ev_is_active (w))) 3661 if (expect_false (!ev_is_active (w)))
3573 return; 3662 return;
3574 3663
… …
3826#else 3915#else
3827# define EV_LSTAT(p,b) lstat (p, b) 3916# define EV_LSTAT(p,b) lstat (p, b)
3828#endif 3917#endif
3829 3918
3830void 3919void
3831ev_stat_stat (EV_P_ ev_stat *w) 3920ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
3832{ 3921{
3833 if (lstat (w->path, &w->attr) < 0) 3922 if (lstat (w->path, &w->attr) < 0)
3834 w->attr.st_nlink = 0; 3923 w->attr.st_nlink = 0;
3835 else if (!w->attr.st_nlink) 3924 else if (!w->attr.st_nlink)
3836 w->attr.st_nlink = 1; 3925 w->attr.st_nlink = 1;
… …
3875 ev_feed_event (EV_A_ w, EV_STAT); 3964 ev_feed_event (EV_A_ w, EV_STAT);
3876 } 3965 }
3877} 3966}
3878 3967
3879void 3968void
3880ev_stat_start (EV_P_ ev_stat *w) 3969ev_stat_start (EV_P_ ev_stat *w) EV_THROW
3881{ 3970{
3882 if (expect_false (ev_is_active (w))) 3971 if (expect_false (ev_is_active (w)))
3883 return; 3972 return;
3884 3973
3885 ev_stat_stat (EV_A_ w); 3974 ev_stat_stat (EV_A_ w);
… …
3906 3995
3907 EV_FREQUENT_CHECK; 3996 EV_FREQUENT_CHECK;
3908} 3997}
3909 3998
3910void 3999void
3911ev_stat_stop (EV_P_ ev_stat *w) 4000ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
3912{ 4001{
3913 clear_pending (EV_A_ (W)w); 4002 clear_pending (EV_A_ (W)w);
3914 if (expect_false (!ev_is_active (w))) 4003 if (expect_false (!ev_is_active (w)))
3915 return; 4004 return;
3916 4005
… …
3932} 4021}
3933#endif 4022#endif
3934 4023
3935#if EV_IDLE_ENABLE 4024#if EV_IDLE_ENABLE
3936void 4025void
3937ev_idle_start (EV_P_ ev_idle *w) 4026ev_idle_start (EV_P_ ev_idle *w) EV_THROW
3938{ 4027{
3939 if (expect_false (ev_is_active (w))) 4028 if (expect_false (ev_is_active (w)))
3940 return; 4029 return;
3941 4030
3942 pri_adjust (EV_A_ (W)w); 4031 pri_adjust (EV_A_ (W)w);
… …
3955 4044
3956 EV_FREQUENT_CHECK; 4045 EV_FREQUENT_CHECK;
3957} 4046}
3958 4047
3959void 4048void
3960ev_idle_stop (EV_P_ ev_idle *w) 4049ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
3961{ 4050{
3962 clear_pending (EV_A_ (W)w); 4051 clear_pending (EV_A_ (W)w);
3963 if (expect_false (!ev_is_active (w))) 4052 if (expect_false (!ev_is_active (w)))
3964 return; 4053 return;
3965 4054
… …
3979} 4068}
3980#endif 4069#endif
3981 4070
3982#if EV_PREPARE_ENABLE 4071#if EV_PREPARE_ENABLE
3983void 4072void
3984ev_prepare_start (EV_P_ ev_prepare *w) 4073ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
3985{ 4074{
3986 if (expect_false (ev_is_active (w))) 4075 if (expect_false (ev_is_active (w)))
3987 return; 4076 return;
3988 4077
3989 EV_FREQUENT_CHECK; 4078 EV_FREQUENT_CHECK;
… …
3994 4083
3995 EV_FREQUENT_CHECK; 4084 EV_FREQUENT_CHECK;
3996} 4085}
3997 4086
3998void 4087void
3999ev_prepare_stop (EV_P_ ev_prepare *w) 4088ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
4000{ 4089{
4001 clear_pending (EV_A_ (W)w); 4090 clear_pending (EV_A_ (W)w);
4002 if (expect_false (!ev_is_active (w))) 4091 if (expect_false (!ev_is_active (w)))
4003 return; 4092 return;
4004 4093
… …
4017} 4106}
4018#endif 4107#endif
4019 4108
4020#if EV_CHECK_ENABLE 4109#if EV_CHECK_ENABLE
4021void 4110void
4022ev_check_start (EV_P_ ev_check *w) 4111ev_check_start (EV_P_ ev_check *w) EV_THROW
4023{ 4112{
4024 if (expect_false (ev_is_active (w))) 4113 if (expect_false (ev_is_active (w)))
4025 return; 4114 return;
4026 4115
4027 EV_FREQUENT_CHECK; 4116 EV_FREQUENT_CHECK;
… …
4032 4121
4033 EV_FREQUENT_CHECK; 4122 EV_FREQUENT_CHECK;
4034} 4123}
4035 4124
4036void 4125void
4037ev_check_stop (EV_P_ ev_check *w) 4126ev_check_stop (EV_P_ ev_check *w) EV_THROW
4038{ 4127{
4039 clear_pending (EV_A_ (W)w); 4128 clear_pending (EV_A_ (W)w);
4040 if (expect_false (!ev_is_active (w))) 4129 if (expect_false (!ev_is_active (w)))
4041 return; 4130 return;
4042 4131
… …
4055} 4144}
4056#endif 4145#endif
4057 4146
4058#if EV_EMBED_ENABLE 4147#if EV_EMBED_ENABLE
4059void noinline 4148void noinline
4060ev_embed_sweep (EV_P_ ev_embed *w) 4149ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
4061{ 4150{
4062 ev_run (w->other, EVRUN_NOWAIT); 4151 ev_run (w->other, EVRUN_NOWAIT);
4063} 4152}
4064 4153
4065static void 4154static void
… …
4113 ev_idle_stop (EV_A_ idle); 4202 ev_idle_stop (EV_A_ idle);
4114} 4203}
4115#endif 4204#endif
4116 4205
4117void 4206void
4118ev_embed_start (EV_P_ ev_embed *w) 4207ev_embed_start (EV_P_ ev_embed *w) EV_THROW
4119{ 4208{
4120 if (expect_false (ev_is_active (w))) 4209 if (expect_false (ev_is_active (w)))
4121 return; 4210 return;
4122 4211
4123 { 4212 {
… …
4144 4233
4145 EV_FREQUENT_CHECK; 4234 EV_FREQUENT_CHECK;
4146} 4235}
4147 4236
4148void 4237void
4149ev_embed_stop (EV_P_ ev_embed *w) 4238ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
4150{ 4239{
4151 clear_pending (EV_A_ (W)w); 4240 clear_pending (EV_A_ (W)w);
4152 if (expect_false (!ev_is_active (w))) 4241 if (expect_false (!ev_is_active (w)))
4153 return; 4242 return;
4154 4243
… …
4164} 4253}
4165#endif 4254#endif
4166 4255
4167#if EV_FORK_ENABLE 4256#if EV_FORK_ENABLE
4168void 4257void
4169ev_fork_start (EV_P_ ev_fork *w) 4258ev_fork_start (EV_P_ ev_fork *w) EV_THROW
4170{ 4259{
4171 if (expect_false (ev_is_active (w))) 4260 if (expect_false (ev_is_active (w)))
4172 return; 4261 return;
4173 4262
4174 EV_FREQUENT_CHECK; 4263 EV_FREQUENT_CHECK;
… …
4179 4268
4180 EV_FREQUENT_CHECK; 4269 EV_FREQUENT_CHECK;
4181} 4270}
4182 4271
4183void 4272void
4184ev_fork_stop (EV_P_ ev_fork *w) 4273ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
4185{ 4274{
4186 clear_pending (EV_A_ (W)w); 4275 clear_pending (EV_A_ (W)w);
4187 if (expect_false (!ev_is_active (w))) 4276 if (expect_false (!ev_is_active (w)))
4188 return; 4277 return;
4189 4278
… …
4202} 4291}
4203#endif 4292#endif
4204 4293
4205#if EV_CLEANUP_ENABLE 4294#if EV_CLEANUP_ENABLE
4206void 4295void
4207ev_cleanup_start (EV_P_ ev_cleanup *w) 4296ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
4208{ 4297{
4209 if (expect_false (ev_is_active (w))) 4298 if (expect_false (ev_is_active (w)))
4210 return; 4299 return;
4211 4300
4212 EV_FREQUENT_CHECK; 4301 EV_FREQUENT_CHECK;
… …
4219 ev_unref (EV_A); 4308 ev_unref (EV_A);
4220 EV_FREQUENT_CHECK; 4309 EV_FREQUENT_CHECK;
4221} 4310}
4222 4311
4223void 4312void
4224ev_cleanup_stop (EV_P_ ev_cleanup *w) 4313ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
4225{ 4314{
4226 clear_pending (EV_A_ (W)w); 4315 clear_pending (EV_A_ (W)w);
4227 if (expect_false (!ev_is_active (w))) 4316 if (expect_false (!ev_is_active (w)))
4228 return; 4317 return;
4229 4318
… …
4243} 4332}
4244#endif 4333#endif
4245 4334
4246#if EV_ASYNC_ENABLE 4335#if EV_ASYNC_ENABLE
4247void 4336void
4248ev_async_start (EV_P_ ev_async *w) 4337ev_async_start (EV_P_ ev_async *w) EV_THROW
4249{ 4338{
4250 if (expect_false (ev_is_active (w))) 4339 if (expect_false (ev_is_active (w)))
4251 return; 4340 return;
4252 4341
4253 w->sent = 0; 4342 w->sent = 0;
… …
4262 4351
4263 EV_FREQUENT_CHECK; 4352 EV_FREQUENT_CHECK;
4264} 4353}
4265 4354
4266void 4355void
4267ev_async_stop (EV_P_ ev_async *w) 4356ev_async_stop (EV_P_ ev_async *w) EV_THROW
4268{ 4357{
4269 clear_pending (EV_A_ (W)w); 4358 clear_pending (EV_A_ (W)w);
4270 if (expect_false (!ev_is_active (w))) 4359 if (expect_false (!ev_is_active (w)))
4271 return; 4360 return;
4272 4361
… …
4283 4372
4284 EV_FREQUENT_CHECK; 4373 EV_FREQUENT_CHECK;
4285} 4374}
4286 4375
4287void 4376void
4288ev_async_send (EV_P_ ev_async *w) 4377ev_async_send (EV_P_ ev_async *w) EV_THROW
4289{ 4378{
4290 w->sent = 1; 4379 w->sent = 1;
4291 evpipe_write (EV_A_ &async_pending); 4380 evpipe_write (EV_A_ &async_pending);
4292} 4381}
4293#endif 4382#endif
… …
4330 4419
4331 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io)); 4420 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4332} 4421}
4333 4422
4334void 4423void
4335ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) 4424ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW
4336{ 4425{
4337 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once)); 4426 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
4338 4427
4339 if (expect_false (!once)) 4428 if (expect_false (!once))
4340 { 4429 {
… …
4362 4451
4363/*****************************************************************************/ 4452/*****************************************************************************/
4364 4453
4365#if EV_WALK_ENABLE 4454#if EV_WALK_ENABLE
4366void ecb_cold 4455void ecb_cold
4367ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) 4456ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
4368{ 4457{
4369 int i, j; 4458 int i, j;
4370 ev_watcher_list *wl, *wn; 4459 ev_watcher_list *wl, *wn;
4371 4460
4372 if (types & (EV_IO | EV_EMBED)) 4461 if (types & (EV_IO | EV_EMBED))

Diff Legend

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