nio4r 0.2.2-java → 0.3.0-java
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/.travis.yml +6 -2
- data/CHANGES.md +10 -0
- data/LICENSE.txt +1 -1
- data/README.md +16 -11
- data/Rakefile +2 -2
- data/examples/echo_server.rb +9 -0
- data/ext/libev/Changes +34 -2
- data/ext/libev/ev.c +694 -131
- data/ext/libev/ev.h +89 -79
- data/ext/libev/ev_epoll.c +23 -10
- data/ext/libev/ev_kqueue.c +4 -4
- data/ext/libev/ev_poll.c +4 -4
- data/ext/libev/ev_port.c +9 -3
- data/ext/libev/ev_select.c +10 -6
- data/ext/libev/ev_vars.h +3 -2
- data/ext/libev/ev_wrap.h +6 -4
- data/ext/nio4r/monitor.c +23 -6
- data/ext/nio4r/org/nio4r/Nio4r.java +409 -0
- data/ext/nio4r/selector.c +36 -8
- data/lib/nio.rb +4 -7
- data/lib/nio/monitor.rb +15 -4
- data/lib/nio/selector.rb +23 -6
- data/lib/nio/version.rb +1 -1
- data/lib/nio4r_ext.jar +0 -0
- data/nio4r.gemspec +4 -3
- data/spec/nio/acceptables_spec.rb +30 -0
- data/spec/nio/monitor_spec.rb +37 -22
- data/spec/nio/selectables_spec.rb +178 -0
- data/spec/nio/selector_spec.rb +71 -173
- data/tasks/extension.rake +6 -5
- metadata +33 -29
- data/lib/nio/jruby/monitor.rb +0 -42
- data/lib/nio/jruby/selector.rb +0 -136
data/ext/libev/ev.h
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
/*
|
2
2
|
* libev native API header
|
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
5
|
* All rights reserved.
|
6
6
|
*
|
7
7
|
* Redistribution and use in source and binary forms, with or without modifica-
|
@@ -185,6 +185,12 @@ struct ev_loop;
|
|
185
185
|
# define EV_INLINE static
|
186
186
|
#endif
|
187
187
|
|
188
|
+
#ifdef EV_API_STATIC
|
189
|
+
# define EV_API_DECL static
|
190
|
+
#else
|
191
|
+
# define EV_API_DECL extern
|
192
|
+
#endif
|
193
|
+
|
188
194
|
/* EV_PROTOTYPES can be used to switch of prototype declarations */
|
189
195
|
#ifndef EV_PROTOTYPES
|
190
196
|
# define EV_PROTOTYPES 1
|
@@ -193,7 +199,7 @@ struct ev_loop;
|
|
193
199
|
/*****************************************************************************/
|
194
200
|
|
195
201
|
#define EV_VERSION_MAJOR 4
|
196
|
-
#define EV_VERSION_MINOR
|
202
|
+
#define EV_VERSION_MINOR 11
|
197
203
|
|
198
204
|
/* eventmask, revents, events... */
|
199
205
|
enum {
|
@@ -508,15 +514,15 @@ enum {
|
|
508
514
|
};
|
509
515
|
|
510
516
|
#if EV_PROTOTYPES
|
511
|
-
int ev_version_major (void);
|
512
|
-
int ev_version_minor (void);
|
517
|
+
EV_API_DECL int ev_version_major (void);
|
518
|
+
EV_API_DECL int ev_version_minor (void);
|
513
519
|
|
514
|
-
unsigned int ev_supported_backends (void);
|
515
|
-
unsigned int ev_recommended_backends (void);
|
516
|
-
unsigned int ev_embeddable_backends (void);
|
520
|
+
EV_API_DECL unsigned int ev_supported_backends (void);
|
521
|
+
EV_API_DECL unsigned int ev_recommended_backends (void);
|
522
|
+
EV_API_DECL unsigned int ev_embeddable_backends (void);
|
517
523
|
|
518
|
-
ev_tstamp ev_time (void);
|
519
|
-
void ev_sleep (ev_tstamp delay); /* sleep for a while */
|
524
|
+
EV_API_DECL ev_tstamp ev_time (void);
|
525
|
+
EV_API_DECL void ev_sleep (ev_tstamp delay); /* sleep for a while */
|
520
526
|
|
521
527
|
/* Sets the allocation function to use, works like realloc.
|
522
528
|
* It is used to allocate and free memory.
|
@@ -524,19 +530,23 @@ void ev_sleep (ev_tstamp delay); /* sleep for a while */
|
|
524
530
|
* or take some potentially destructive action.
|
525
531
|
* The default is your system realloc function.
|
526
532
|
*/
|
527
|
-
void ev_set_allocator (void *(*cb)(void *ptr, long size));
|
533
|
+
EV_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size));
|
528
534
|
|
529
535
|
/* set the callback function to call on a
|
530
536
|
* retryable syscall error
|
531
537
|
* (such as failed select, poll, epoll_wait)
|
532
538
|
*/
|
533
|
-
void ev_set_syserr_cb (void (*cb)(const char *msg));
|
539
|
+
EV_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg));
|
534
540
|
|
535
541
|
#if EV_MULTIPLICITY
|
536
542
|
|
537
543
|
/* the default loop is the only one that handles signals and child watchers */
|
538
544
|
/* you can call this as often as you like */
|
539
|
-
struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0));
|
545
|
+
EV_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0));
|
546
|
+
|
547
|
+
#ifdef EV_API_STATIC
|
548
|
+
EV_API_DECL struct ev_loop *ev_default_loop_ptr;
|
549
|
+
#endif
|
540
550
|
|
541
551
|
EV_INLINE struct ev_loop *
|
542
552
|
ev_default_loop_uc_ (void)
|
@@ -553,19 +563,19 @@ ev_is_default_loop (EV_P)
|
|
553
563
|
}
|
554
564
|
|
555
565
|
/* create and destroy alternative loops that don't handle signals */
|
556
|
-
struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0));
|
566
|
+
EV_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0));
|
557
567
|
|
558
|
-
ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
|
568
|
+
EV_API_DECL ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
|
559
569
|
|
560
570
|
#else
|
561
571
|
|
562
|
-
int ev_default_loop (unsigned int flags EV_CPP (= 0)); /* returns true when successful */
|
572
|
+
EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)); /* returns true when successful */
|
573
|
+
|
574
|
+
EV_API_DECL ev_tstamp ev_rt_now;
|
563
575
|
|
564
576
|
EV_INLINE ev_tstamp
|
565
577
|
ev_now (void)
|
566
578
|
{
|
567
|
-
extern ev_tstamp ev_rt_now;
|
568
|
-
|
569
579
|
return ev_rt_now;
|
570
580
|
}
|
571
581
|
|
@@ -579,23 +589,23 @@ ev_is_default_loop (void)
|
|
579
589
|
#endif /* multiplicity */
|
580
590
|
|
581
591
|
/* destroy event loops, also works for the default loop */
|
582
|
-
void ev_loop_destroy (EV_P);
|
592
|
+
EV_API_DECL void ev_loop_destroy (EV_P);
|
583
593
|
|
584
594
|
/* this needs to be called after fork, to duplicate the loop */
|
585
595
|
/* when you want to re-use it in the child */
|
586
596
|
/* you can call it in either the parent or the child */
|
587
597
|
/* you can actually call it at any time, anywhere :) */
|
588
|
-
void ev_loop_fork (EV_P);
|
598
|
+
EV_API_DECL void ev_loop_fork (EV_P);
|
589
599
|
|
590
|
-
unsigned int ev_backend (EV_P); /* backend in use by loop */
|
600
|
+
EV_API_DECL unsigned int ev_backend (EV_P); /* backend in use by loop */
|
591
601
|
|
592
|
-
void ev_now_update (EV_P); /* update event loop time */
|
602
|
+
EV_API_DECL void ev_now_update (EV_P); /* update event loop time */
|
593
603
|
|
594
604
|
#if EV_WALK_ENABLE
|
595
605
|
/* walk (almost) all watchers in the loop of a given type, invoking the */
|
596
606
|
/* callback on every such watcher. The callback might stop the watcher, */
|
597
607
|
/* but do nothing else with the loop */
|
598
|
-
void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w));
|
608
|
+
EV_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w));
|
599
609
|
#endif
|
600
610
|
|
601
611
|
#endif /* prototypes */
|
@@ -614,45 +624,45 @@ enum {
|
|
614
624
|
};
|
615
625
|
|
616
626
|
#if EV_PROTOTYPES
|
617
|
-
void ev_run (EV_P_ int flags EV_CPP (= 0));
|
618
|
-
void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)); /* break out of the loop */
|
627
|
+
EV_API_DECL void ev_run (EV_P_ int flags EV_CPP (= 0));
|
628
|
+
EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)); /* break out of the loop */
|
619
629
|
|
620
630
|
/*
|
621
631
|
* ref/unref can be used to add or remove a refcount on the mainloop. every watcher
|
622
632
|
* keeps one reference. if you have a long-running watcher you never unregister that
|
623
633
|
* should not keep ev_loop from running, unref() after starting, and ref() before stopping.
|
624
634
|
*/
|
625
|
-
void ev_ref (EV_P);
|
626
|
-
void ev_unref (EV_P);
|
635
|
+
EV_API_DECL void ev_ref (EV_P);
|
636
|
+
EV_API_DECL void ev_unref (EV_P);
|
627
637
|
|
628
638
|
/*
|
629
639
|
* convenience function, wait for a single event, without registering an event watcher
|
630
640
|
* if timeout is < 0, do wait indefinitely
|
631
641
|
*/
|
632
|
-
void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg);
|
642
|
+
EV_API_DECL void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg);
|
633
643
|
|
634
644
|
# if EV_FEATURE_API
|
635
|
-
unsigned int ev_iteration (EV_P); /* number of loop iterations */
|
636
|
-
unsigned int ev_depth (EV_P); /* #ev_loop enters - #ev_loop leaves */
|
637
|
-
void ev_verify (EV_P); /* abort if loop data corrupted */
|
645
|
+
EV_API_DECL unsigned int ev_iteration (EV_P); /* number of loop iterations */
|
646
|
+
EV_API_DECL unsigned int ev_depth (EV_P); /* #ev_loop enters - #ev_loop leaves */
|
647
|
+
EV_API_DECL void ev_verify (EV_P); /* abort if loop data corrupted */
|
638
648
|
|
639
|
-
void ev_set_io_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
|
640
|
-
void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
|
649
|
+
EV_API_DECL void ev_set_io_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
|
650
|
+
EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
|
641
651
|
|
642
652
|
/* advanced stuff for threading etc. support, see docs */
|
643
|
-
void ev_set_userdata (EV_P_ void *data);
|
644
|
-
void *ev_userdata (EV_P);
|
645
|
-
void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P));
|
646
|
-
void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P));
|
653
|
+
EV_API_DECL void ev_set_userdata (EV_P_ void *data);
|
654
|
+
EV_API_DECL void *ev_userdata (EV_P);
|
655
|
+
EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P));
|
656
|
+
EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P));
|
647
657
|
|
648
|
-
unsigned int ev_pending_count (EV_P); /* number of pending events, if any */
|
649
|
-
void ev_invoke_pending (EV_P); /* invoke all pending watchers */
|
658
|
+
EV_API_DECL unsigned int ev_pending_count (EV_P); /* number of pending events, if any */
|
659
|
+
EV_API_DECL void ev_invoke_pending (EV_P); /* invoke all pending watchers */
|
650
660
|
|
651
661
|
/*
|
652
662
|
* stop/start the timer handling.
|
653
663
|
*/
|
654
|
-
void ev_suspend (EV_P);
|
655
|
-
void ev_resume (EV_P);
|
664
|
+
EV_API_DECL void ev_suspend (EV_P);
|
665
|
+
EV_API_DECL void ev_resume (EV_P);
|
656
666
|
#endif
|
657
667
|
|
658
668
|
#endif
|
@@ -717,87 +727,87 @@ void ev_resume (EV_P);
|
|
717
727
|
/* stopping (disabling, deleting) a watcher does nothing unless its already running */
|
718
728
|
#if EV_PROTOTYPES
|
719
729
|
|
720
|
-
/* feeds an event into a watcher as if the event actually
|
730
|
+
/* feeds an event into a watcher as if the event actually occurred */
|
721
731
|
/* accepts any ev_watcher type */
|
722
|
-
void ev_feed_event (EV_P_ void *w, int revents);
|
723
|
-
void ev_feed_fd_event (EV_P_ int fd, int revents);
|
732
|
+
EV_API_DECL void ev_feed_event (EV_P_ void *w, int revents);
|
733
|
+
EV_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents);
|
724
734
|
#if EV_SIGNAL_ENABLE
|
725
|
-
void ev_feed_signal (int signum);
|
726
|
-
void ev_feed_signal_event (EV_P_ int signum);
|
735
|
+
EV_API_DECL void ev_feed_signal (int signum);
|
736
|
+
EV_API_DECL void ev_feed_signal_event (EV_P_ int signum);
|
727
737
|
#endif
|
728
|
-
void ev_invoke (EV_P_ void *w, int revents);
|
729
|
-
int ev_clear_pending (EV_P_ void *w);
|
738
|
+
EV_API_DECL void ev_invoke (EV_P_ void *w, int revents);
|
739
|
+
EV_API_DECL int ev_clear_pending (EV_P_ void *w);
|
730
740
|
|
731
|
-
void ev_io_start (EV_P_ ev_io *w);
|
732
|
-
void ev_io_stop (EV_P_ ev_io *w);
|
741
|
+
EV_API_DECL void ev_io_start (EV_P_ ev_io *w);
|
742
|
+
EV_API_DECL void ev_io_stop (EV_P_ ev_io *w);
|
733
743
|
|
734
|
-
void ev_timer_start (EV_P_ ev_timer *w);
|
735
|
-
void ev_timer_stop (EV_P_ ev_timer *w);
|
744
|
+
EV_API_DECL void ev_timer_start (EV_P_ ev_timer *w);
|
745
|
+
EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w);
|
736
746
|
/* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
|
737
|
-
void ev_timer_again (EV_P_ ev_timer *w);
|
747
|
+
EV_API_DECL void ev_timer_again (EV_P_ ev_timer *w);
|
738
748
|
/* return remaining time */
|
739
|
-
ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w);
|
749
|
+
EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w);
|
740
750
|
|
741
751
|
#if EV_PERIODIC_ENABLE
|
742
|
-
void ev_periodic_start (EV_P_ ev_periodic *w);
|
743
|
-
void ev_periodic_stop (EV_P_ ev_periodic *w);
|
744
|
-
void ev_periodic_again (EV_P_ ev_periodic *w);
|
752
|
+
EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w);
|
753
|
+
EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w);
|
754
|
+
EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w);
|
745
755
|
#endif
|
746
756
|
|
747
757
|
/* only supported in the default loop */
|
748
758
|
#if EV_SIGNAL_ENABLE
|
749
|
-
void ev_signal_start (EV_P_ ev_signal *w);
|
750
|
-
void ev_signal_stop (EV_P_ ev_signal *w);
|
759
|
+
EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w);
|
760
|
+
EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w);
|
751
761
|
#endif
|
752
762
|
|
753
763
|
/* only supported in the default loop */
|
754
764
|
# if EV_CHILD_ENABLE
|
755
|
-
void ev_child_start (EV_P_ ev_child *w);
|
756
|
-
void ev_child_stop (EV_P_ ev_child *w);
|
765
|
+
EV_API_DECL void ev_child_start (EV_P_ ev_child *w);
|
766
|
+
EV_API_DECL void ev_child_stop (EV_P_ ev_child *w);
|
757
767
|
# endif
|
758
768
|
|
759
769
|
# if EV_STAT_ENABLE
|
760
|
-
void ev_stat_start (EV_P_ ev_stat *w);
|
761
|
-
void ev_stat_stop (EV_P_ ev_stat *w);
|
762
|
-
void ev_stat_stat (EV_P_ ev_stat *w);
|
770
|
+
EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w);
|
771
|
+
EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w);
|
772
|
+
EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w);
|
763
773
|
# endif
|
764
774
|
|
765
775
|
# if EV_IDLE_ENABLE
|
766
|
-
void ev_idle_start (EV_P_ ev_idle *w);
|
767
|
-
void ev_idle_stop (EV_P_ ev_idle *w);
|
776
|
+
EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w);
|
777
|
+
EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w);
|
768
778
|
# endif
|
769
779
|
|
770
780
|
#if EV_PREPARE_ENABLE
|
771
|
-
void ev_prepare_start (EV_P_ ev_prepare *w);
|
772
|
-
void ev_prepare_stop (EV_P_ ev_prepare *w);
|
781
|
+
EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w);
|
782
|
+
EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w);
|
773
783
|
#endif
|
774
784
|
|
775
785
|
#if EV_CHECK_ENABLE
|
776
|
-
void ev_check_start (EV_P_ ev_check *w);
|
777
|
-
void ev_check_stop (EV_P_ ev_check *w);
|
786
|
+
EV_API_DECL void ev_check_start (EV_P_ ev_check *w);
|
787
|
+
EV_API_DECL void ev_check_stop (EV_P_ ev_check *w);
|
778
788
|
#endif
|
779
789
|
|
780
790
|
# if EV_FORK_ENABLE
|
781
|
-
void ev_fork_start (EV_P_ ev_fork *w);
|
782
|
-
void ev_fork_stop (EV_P_ ev_fork *w);
|
791
|
+
EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w);
|
792
|
+
EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w);
|
783
793
|
# endif
|
784
794
|
|
785
795
|
# if EV_CLEANUP_ENABLE
|
786
|
-
void ev_cleanup_start (EV_P_ ev_cleanup *w);
|
787
|
-
void ev_cleanup_stop (EV_P_ ev_cleanup *w);
|
796
|
+
EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w);
|
797
|
+
EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w);
|
788
798
|
# endif
|
789
799
|
|
790
800
|
# if EV_EMBED_ENABLE
|
791
801
|
/* only supported when loop to be embedded is in fact embeddable */
|
792
|
-
void ev_embed_start (EV_P_ ev_embed *w);
|
793
|
-
void ev_embed_stop (EV_P_ ev_embed *w);
|
794
|
-
void ev_embed_sweep (EV_P_ ev_embed *w);
|
802
|
+
EV_API_DECL void ev_embed_start (EV_P_ ev_embed *w);
|
803
|
+
EV_API_DECL void ev_embed_stop (EV_P_ ev_embed *w);
|
804
|
+
EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w);
|
795
805
|
# endif
|
796
806
|
|
797
807
|
# if EV_ASYNC_ENABLE
|
798
|
-
void ev_async_start (EV_P_ ev_async *w);
|
799
|
-
void ev_async_stop (EV_P_ ev_async *w);
|
800
|
-
void ev_async_send (EV_P_ ev_async *w);
|
808
|
+
EV_API_DECL void ev_async_start (EV_P_ ev_async *w);
|
809
|
+
EV_API_DECL void ev_async_stop (EV_P_ ev_async *w);
|
810
|
+
EV_API_DECL void ev_async_send (EV_P_ ev_async *w);
|
801
811
|
# endif
|
802
812
|
|
803
813
|
#if EV_COMPAT3
|
data/ext/libev/ev_epoll.c
CHANGED
@@ -144,11 +144,13 @@ epoll_poll (EV_P_ ev_tstamp timeout)
|
|
144
144
|
int i;
|
145
145
|
int eventcnt;
|
146
146
|
|
147
|
+
if (expect_false (epoll_epermcnt))
|
148
|
+
timeout = 0.;
|
149
|
+
|
147
150
|
/* epoll wait times cannot be larger than (LONG_MAX - 999UL) / HZ msecs, which is below */
|
148
151
|
/* the default libev max wait time, however. */
|
149
152
|
EV_RELEASE_CB;
|
150
|
-
eventcnt = epoll_wait (backend_fd, epoll_events, epoll_eventmax,
|
151
|
-
epoll_epermcnt ? 0 : ev_timeout_to_ms (timeout));
|
153
|
+
eventcnt = epoll_wait (backend_fd, epoll_events, epoll_eventmax, timeout * 1e3);
|
152
154
|
EV_ACQUIRE_CB;
|
153
155
|
|
154
156
|
if (expect_false (eventcnt < 0))
|
@@ -168,8 +170,12 @@ epoll_poll (EV_P_ ev_tstamp timeout)
|
|
168
170
|
int got = (ev->events & (EPOLLOUT | EPOLLERR | EPOLLHUP) ? EV_WRITE : 0)
|
169
171
|
| (ev->events & (EPOLLIN | EPOLLERR | EPOLLHUP) ? EV_READ : 0);
|
170
172
|
|
171
|
-
/*
|
172
|
-
|
173
|
+
/*
|
174
|
+
* check for spurious notification.
|
175
|
+
* this only finds spurious notifications on egen updates
|
176
|
+
* other spurious notifications will be found by epoll_ctl, below
|
177
|
+
* we assume that fd is always in range, as we never shrink the anfds array
|
178
|
+
*/
|
173
179
|
if (expect_false ((uint32_t)anfds [fd].egen != (uint32_t)(ev->data.u64 >> 32)))
|
174
180
|
{
|
175
181
|
/* recreate kernel state */
|
@@ -181,8 +187,15 @@ epoll_poll (EV_P_ ev_tstamp timeout)
|
|
181
187
|
{
|
182
188
|
anfds [fd].emask = want;
|
183
189
|
|
184
|
-
/*
|
185
|
-
|
190
|
+
/*
|
191
|
+
* we received an event but are not interested in it, try mod or del
|
192
|
+
* this often happens because we optimistically do not unregister fds
|
193
|
+
* when we are no longer interested in them, but also when we get spurious
|
194
|
+
* notifications for fds from another process. this is partially handled
|
195
|
+
* above with the gencounter check (== our fd is not the event fd), and
|
196
|
+
* partially here, when epoll_ctl returns an error (== a child has the fd
|
197
|
+
* but we closed it).
|
198
|
+
*/
|
186
199
|
ev->events = (want & EV_READ ? EPOLLIN : 0)
|
187
200
|
| (want & EV_WRITE ? EPOLLOUT : 0);
|
188
201
|
|
@@ -225,7 +238,7 @@ epoll_init (EV_P_ int flags)
|
|
225
238
|
#ifdef EPOLL_CLOEXEC
|
226
239
|
backend_fd = epoll_create1 (EPOLL_CLOEXEC);
|
227
240
|
|
228
|
-
if (backend_fd
|
241
|
+
if (backend_fd < 0)
|
229
242
|
#endif
|
230
243
|
backend_fd = epoll_create (256);
|
231
244
|
|
@@ -234,9 +247,9 @@ epoll_init (EV_P_ int flags)
|
|
234
247
|
|
235
248
|
fcntl (backend_fd, F_SETFD, FD_CLOEXEC);
|
236
249
|
|
237
|
-
|
238
|
-
backend_modify
|
239
|
-
backend_poll
|
250
|
+
backend_mintime = 1e-3; /* epoll does sometimes return early, this is just to avoid the worst */
|
251
|
+
backend_modify = epoll_modify;
|
252
|
+
backend_poll = epoll_poll;
|
240
253
|
|
241
254
|
epoll_eventmax = 64; /* initial number of events receivable per poll */
|
242
255
|
epoll_events = (struct epoll_event *)ev_malloc (sizeof (struct epoll_event) * epoll_eventmax);
|
data/ext/libev/ev_kqueue.c
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
/*
|
2
2
|
* libev kqueue backend
|
3
3
|
*
|
4
|
-
* Copyright (c) 2007,2008,2009,2010 Marc Alexander Lehmann <libev@schmorp.de>
|
4
|
+
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
|
5
5
|
* All rights reserved.
|
6
6
|
*
|
7
7
|
* Redistribution and use in source and binary forms, with or without modifica-
|
@@ -161,9 +161,9 @@ kqueue_init (EV_P_ int flags)
|
|
161
161
|
|
162
162
|
fcntl (backend_fd, F_SETFD, FD_CLOEXEC); /* not sure if necessary, hopefully doesn't hurt */
|
163
163
|
|
164
|
-
|
165
|
-
backend_modify
|
166
|
-
backend_poll
|
164
|
+
backend_mintime = 1e-9; /* apparently, they did the right thing in freebsd */
|
165
|
+
backend_modify = kqueue_modify;
|
166
|
+
backend_poll = kqueue_poll;
|
167
167
|
|
168
168
|
kqueue_eventmax = 64; /* initial number of events receivable per poll */
|
169
169
|
kqueue_events = (struct kevent *)ev_malloc (sizeof (struct kevent) * kqueue_eventmax);
|
data/ext/libev/ev_poll.c
CHANGED
@@ -92,7 +92,7 @@ poll_poll (EV_P_ ev_tstamp timeout)
|
|
92
92
|
int res;
|
93
93
|
|
94
94
|
EV_RELEASE_CB;
|
95
|
-
res = poll (polls, pollcnt,
|
95
|
+
res = poll (polls, pollcnt, timeout * 1e3);
|
96
96
|
EV_ACQUIRE_CB;
|
97
97
|
|
98
98
|
if (expect_false (res < 0))
|
@@ -129,9 +129,9 @@ poll_poll (EV_P_ ev_tstamp timeout)
|
|
129
129
|
int inline_size
|
130
130
|
poll_init (EV_P_ int flags)
|
131
131
|
{
|
132
|
-
|
133
|
-
backend_modify
|
134
|
-
backend_poll
|
132
|
+
backend_mintime = 1e-3;
|
133
|
+
backend_modify = poll_modify;
|
134
|
+
backend_poll = poll_poll;
|
135
135
|
|
136
136
|
pollidxs = 0; pollidxmax = 0;
|
137
137
|
polls = 0; pollmax = 0; pollcnt = 0;
|
data/ext/libev/ev_port.c
CHANGED
@@ -147,9 +147,15 @@ port_init (EV_P_ int flags)
|
|
147
147
|
|
148
148
|
fcntl (backend_fd, F_SETFD, FD_CLOEXEC); /* not sure if necessary, hopefully doesn't hurt */
|
149
149
|
|
150
|
-
|
151
|
-
|
152
|
-
|
150
|
+
/* if my reading of the opensolaris kernel sources are correct, then
|
151
|
+
* opensolaris does something very stupid: it checks if the time has already
|
152
|
+
* elapsed and doesn't round up if that is the case,m otherwise it DOES round
|
153
|
+
* up. Since we can't know what the case is, we need to guess by using a
|
154
|
+
* "large enough" timeout. Normally, 1e-9 would be correct.
|
155
|
+
*/
|
156
|
+
backend_mintime = 1e-3; /* needed to compensate for port_getn returning early */
|
157
|
+
backend_modify = port_modify;
|
158
|
+
backend_poll = port_poll;
|
153
159
|
|
154
160
|
port_eventmax = 64; /* initial number of events receivable per poll */
|
155
161
|
port_events = (port_event_t *)ev_malloc (sizeof (port_event_t) * port_eventmax);
|