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

Comparing libev/ev.pod (file contents):
Revision 1.254 by root, Tue Jul 14 19:02:43 2009 UTC vs.
Revision 1.256 by root, Tue Jul 14 20:31:21 2009 UTC

… …
862 862
863This call will simply invoke all pending watchers while resetting their 863This call will simply invoke all pending watchers while resetting their
864pending state. Normally, C<ev_loop> does this automatically when required, 864pending state. Normally, C<ev_loop> does this automatically when required,
865but when overriding the invoke callback this call comes handy. 865but when overriding the invoke callback this call comes handy.
866 866
867=item int ev_pending_count (loop)
868
869Returns the number of pending watchers - zero indicates that no watchers
870are pending.
871
867=item ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(EV_P)) 872=item ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(EV_P))
868 873
869This overrides the invoke pending functionality of the loop: Instead of 874This overrides the invoke pending functionality of the loop: Instead of
870invoking all pending watchers when there are any, C<ev_loop> will call 875invoking all pending watchers when there are any, C<ev_loop> will call
871this callback instead. This is useful, for example, when you want to 876this callback instead. This is useful, for example, when you want to
… …
3998protecting the loop data, respectively. 4003protecting the loop data, respectively.
3999 4004
4000 static void 4005 static void
4001 l_release (EV_P) 4006 l_release (EV_P)
4002 { 4007 {
4003 udat *u = ev_userdata (EV_A); 4008 userdata *u = ev_userdata (EV_A);
4004 pthread_mutex_unlock (&u->lock); 4009 pthread_mutex_unlock (&u->lock);
4005 } 4010 }
4006 4011
4007 static void 4012 static void
4008 l_acquire (EV_P) 4013 l_acquire (EV_P)
4009 { 4014 {
4010 udat *u = ev_userdata (EV_A); 4015 userdata *u = ev_userdata (EV_A);
4011 pthread_mutex_lock (&u->lock); 4016 pthread_mutex_lock (&u->lock);
4012 } 4017 }
4013 4018
4014The event loop thread first acquires the mutex, and then jumps straight 4019The event loop thread first acquires the mutex, and then jumps straight
4015into C<ev_loop>: 4020into C<ev_loop>:
… …
4028 } 4033 }
4029 4034
4030Instead of invoking all pending watchers, the C<l_invoke> callback will 4035Instead of invoking all pending watchers, the C<l_invoke> callback will
4031signal the main thread via some unspecified mechanism (signals? pipe 4036signal the main thread via some unspecified mechanism (signals? pipe
4032writes? C<Async::Interrupt>?) and then waits until all pending watchers 4037writes? C<Async::Interrupt>?) and then waits until all pending watchers
4033have been called: 4038have been called (in a while loop because a) spurious wakeups are possible
4039and b) skipping inter-thread-communication when there are no pending
4040watchers is very beneficial):
4034 4041
4035 static void 4042 static void
4036 l_invoke (EV_P) 4043 l_invoke (EV_P)
4037 { 4044 {
4038 udat *u = ev_userdata (EV_A); 4045 userdata *u = ev_userdata (EV_A);
4039 4046
4047 while (ev_pending_count (EV_A))
4048 {
4040 wake_up_other_thread_in_some_magic_or_not_so_magic_way (); 4049 wake_up_other_thread_in_some_magic_or_not_so_magic_way ();
4041
4042 pthread_cond_wait (&u->invoke_cv, &u->lock); 4050 pthread_cond_wait (&u->invoke_cv, &u->lock);
4051 }
4043 } 4052 }
4044 4053
4045Now, whenever the main thread gets told to invoke pending watchers, it 4054Now, whenever the main thread gets told to invoke pending watchers, it
4046will grab the lock, call C<ev_invoke_pending> and then signal the loop 4055will grab the lock, call C<ev_invoke_pending> and then signal the loop
4047thread to continue: 4056thread to continue:
4048 4057
4049 static void 4058 static void
4050 real_invoke_pending (EV_P) 4059 real_invoke_pending (EV_P)
4051 { 4060 {
4052 udat *u = ev_userdata (EV_A); 4061 userdata *u = ev_userdata (EV_A);
4053 4062
4054 pthread_mutex_lock (&u->lock); 4063 pthread_mutex_lock (&u->lock);
4055 ev_invoke_pending (EV_A); 4064 ev_invoke_pending (EV_A);
4056 pthread_cond_signal (&u->invoke_cv); 4065 pthread_cond_signal (&u->invoke_cv);
4057 pthread_mutex_unlock (&u->lock); 4066 pthread_mutex_unlock (&u->lock);
… …
4059 4068
4060Whenever you want to start/stop a watcher or do other modifications to an 4069Whenever you want to start/stop a watcher or do other modifications to an
4061event loop, you will now have to lock: 4070event loop, you will now have to lock:
4062 4071
4063 ev_timer timeout_watcher; 4072 ev_timer timeout_watcher;
4064 udat *u = ev_userdata (EV_A); 4073 userdata *u = ev_userdata (EV_A);
4065 4074
4066 ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); 4075 ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
4067 4076
4068 pthread_mutex_lock (&u->lock); 4077 pthread_mutex_lock (&u->lock);
4069 ev_timer_start (EV_A_ &timeout_watcher); 4078 ev_timer_start (EV_A_ &timeout_watcher);
… …
4078=head3 COROUTINES 4087=head3 COROUTINES
4079 4088
4080Libev is very accommodating to coroutines ("cooperative threads"): 4089Libev is very accommodating to coroutines ("cooperative threads"):
4081libev fully supports nesting calls to its functions from different 4090libev fully supports nesting calls to its functions from different
4082coroutines (e.g. you can call C<ev_loop> on the same loop from two 4091coroutines (e.g. you can call C<ev_loop> on the same loop from two
4083different coroutines, and switch freely between both coroutines running the 4092different coroutines, and switch freely between both coroutines running
4084loop, as long as you don't confuse yourself). The only exception is that 4093the loop, as long as you don't confuse yourself). The only exception is
4085you must not do this from C<ev_periodic> reschedule callbacks. 4094that you must not do this from C<ev_periodic> reschedule callbacks.
4086 4095
4087Care has been taken to ensure that libev does not keep local state inside 4096Care has been taken to ensure that libev does not keep local state inside
4088C<ev_loop>, and other calls do not usually allow for coroutine switches as 4097C<ev_loop>, and other calls do not usually allow for coroutine switches as
4089they do not call any callbacks. 4098they do not call any callbacks.
4090 4099

Diff Legend

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