event::rpc::loop(3pm) [debian man page]

Event::RPC::Loop(3pm)					User Contributed Perl Documentation				     Event::RPC::Loop(3pm)

NAME

       Event::RPC::Loop - Mainloop Abstraction layer for Event::RPC

SYNOPSIS

	 use Event::RPC::Server;
	 use Event::RPC::Loop::Glib;

	 my $server = Event::RPC::Server->new (
	     ...
	     loop => Event::RPC::Loop::Glib->new(),
	     ...
	 );

	 $server->start;

DESCRIPTION

       This modules defines the interface of Event::RPC's mainloop abstraction layer. It's a virtual class all mainloop modules should inherit
       from.

INTERFACE

       The following methods need to be implemented:

       $loop->enter ()
	   Enter resp. start a mainloop.

       $loop->leave ()
	   Leave the mainloop, which was started with the enter() method.

       $watcher = $loop->add_io_watcher ( %options )
	   Add an I/O watcher. Options are passed as a hash of key/value pairs. The following options are known:

	   fh  The filehandle to be watched.

	   cb  This callback is called, without any parameters, if an event occured on the filehandle above.

	   desc
	       A description of the watcher. Not necessarily implemented by all modules, so it may be ignored.

	   poll
	       Either 'r', if your program reads from the filehandle, or 'w' if it writes to it.

	   A watcher object is returned. What this exactly is depends on the implementation, so you can't do anything useful with it besides
	   passing it back to del_io_watcher().

       $loop->del_io_watcher ( $watcher )
	   Deletes an I/O watcher which was added with $loop->add_io_watcher().

       $timer = $loop->add_timer ( %options )
	   This sets a timer, a subroutine called after a specific timeout or on a regularly basis with a fixed time interval.

	   Options are passed as a hash of key/value pairs. The following options are known:

	   interval
	       A time interval in seconds, may be fractional.

	   after
	       Callback is called once after this amount of seconds, may be fractional.

	   cb  The callback.

	   desc
	       A description of the timer. Not necessarily implemented by all modules, so it may be ignored.

	   A timer object is returned. What this exactly is depends on the implementation, so you can't do anything useful with it besides passing
	   it back to del_io_timer().

       $loop->del_timer ( $timer )
	   Deletes a timer which was added with $loop->add_timer().

DIRECT USAGE IN YOUR SERVER

       You may use the methods of Event::RPC::Loop by yourself if you like. This way your program keeps independent of the actual mainloop module
       in use, if the simplified interface of Event::RPC::Loop is sufficient for you.

       In your server program you access the actual mainloop object this way:

	 my $loop = Event::RPC::Server->instance->get_loop;

       Naturally nothing speaks against making your program to work only with a specific mainloop implementation, if you need its features. In
       that case you may use the corresponding API directly (e.g. of Event or Glib), no need to access it through Event::RPC::Loop.

AUTHORS

	 Joern Reder <joern at zyn dot de>

COPYRIGHT AND LICENSE

       Copyright (C) 2002-2006 by Joern Reder, All Rights Reserved.

       This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

perl v5.10.1							    2006-04-23						     Event::RPC::Loop(3pm)

AnyEvent::Loop(3pm)					User Contributed Perl Documentation				       AnyEvent::Loop(3pm)

NAME

       AnyEvent::Loop - AnyEvent's Pure-Perl event loop

SYNOPSIS

	  use AnyEvent;
	  # use AnyEvent::Loop;

	  # this module gets loaded automatically when no other loop can be found

	  # Explicit use:
	  use AnyEvent::Loop;
	  use AnyEvent;

	  ...

	  AnyEvent::Loop::run; # run the event loop

DESCRIPTION

       This module provides an event loop for AnyEvent in case no other event loop could be found or loaded. You don't have to do anything to make
       it work with AnyEvent except by possibly loading it before creating the first AnyEvent watcher.

       This module is not some loop abstracion used by AnyEvent, but just another event loop like EV or Glib, just written in pure perl and
       delivered with AnyEvent, so AnyEvent always works, even in the absence of any other backend.

       If you want to use this module instead of autoloading a potentially better event loop you can simply load it (and no other event loops)
       before creating the first watcher.

       As for performance, this module is on par with (and usually faster than) most select/poll-based C event modules such as Event or Glib (it
       does not even come close to EV, though), with respect to I/O watchers. Timers are handled less optimally, but for many common tasks, it is
       still on par with event loops written in C.

       This event loop has been optimised for the following use cases:

       monotonic clock is available
	   This module will use the POSIX monotonic clock option (if it can be detected at runtime) or the POSIX "times" function (if the
	   resolution is at least 100Hz), in which case it will not suffer adversely from time jumps.

	   If no monotonic clock is available, this module will not attempt to correct for time jumps in any way.

	   The clock chosen will be reported if the environment variable $PERL_ANYEVENT_VERBOSE is set to 8 or higher.

       any number of watchers on one fd
	   Supporting a large number of watchers per fd is purely a dirty benchmark optimisation not relevant in practise. The more common case of
	   having one watcher per fd/poll combo is special-cased, however, and therefore fast, too.

       relatively few active fds per "select" call
	   This module expects that only a tiny amount of fds is active at any one time. This is relatively typical of larger servers (but not the
	   case where "select" traditionally is fast), at the expense of the "dense activity case" where most of the fds are active (which suits
	   "select").

	   The optimal implementation of the "dense" case is not much faster, though, so the module should behave very well in most cases, subject
	   to the bad scalability of "select" in the presence of a large number of inactive file descriptors.

       lots of timer changes/iteration, or none at all
	   This module sorts the timer list using perl's "sort", even though a total ordering is not required for timers internally.

	   This sorting is expensive, but means sorting can be avoided unless the timer list has changed in a way that requires a new sort.

	   This means that adding lots of timers is very efficient, as well as not changing the timers. Advancing timers (e.g. recreating a
	   timeout watcher on activity) is also relatively efficient, for example, if you have a large number of timeout watchers that time out
	   after 10 seconds, then the timer list will be sorted only once every 10 seconds.

	   This should not have much of an impact unless you have hundreds or thousands of timers, though, or your timers have very small
	   timeouts.

FUNCTIONS

       The only user-visible functions provided by this module loop related - watchers are created via the normal AnyEvent mechanisms.

       AnyEvent::Loop::run
	   Run the event loop, usually the last thing done in the main program when you want to use the pure-perl backend.

       AnyEvent::Loop::one_event
	   Blocks until at least one new event has been received by the operating system, whether or not it was AnyEvent-related.

SEE ALSO

       AnyEvent.

AUTHOR

	  Marc Lehmann <schmorp@schmorp.de>
	  http://anyevent.schmorp.de

perl v5.14.2							    2012-04-08						       AnyEvent::Loop(3pm)