ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.68 by root, Fri Apr 25 07:14:33 2008 UTC vs.
Revision 1.77 by root, Fri Apr 25 09:00:37 2008 UTC

… …
864 864
865 865
866=head1 BENCHMARK 866=head1 BENCHMARK
867 867
868To give you an idea of the performance and overheads that AnyEvent adds 868To give you an idea of the performance and overheads that AnyEvent adds
869over the event loops themselves (and to give you an impression of the
869over the event loops directly, here is a benchmark of various supported 870speed of various event loops), here is a benchmark of various supported
870event models natively and with anyevent. The benchmark creates a lot of 871event models natively and with anyevent. The benchmark creates a lot of
871timers (with a zero timeout) and io watchers (watching STDOUT, a pty, to 872timers (with a zero timeout) and io watchers (watching STDOUT, a pty, to
872become writable, which it is), lets them fire exactly once and destroys 873become writable, which it is), lets them fire exactly once and destroys
873them again. 874them again.
874 875
876Rewriting the benchmark to use many different sockets instead of using
877the same filehandle for all io watchers results in a much longer runtime
878(socket creation is expensive), but qualitatively the same figures, so it
879was not used.
880
875=head2 Explanation of the fields 881=head2 Explanation of the columns
876 882
877I<watcher> is the number of event watchers created/destroyed. Since 883I<watcher> is the number of event watchers created/destroyed. Since
878different event models feature vastly different performances, each event 884different event models feature vastly different performances, each event
879loop was given a number of watchers so that overall runtime is acceptable 885loop was given a number of watchers so that overall runtime is acceptable
880and similar between tested event loop (and keep them from crashing): Glib 886and similar between tested event loop (and keep them from crashing): Glib
… …
890all watchers, to avoid adding memory overhead. That means closure creation 896all watchers, to avoid adding memory overhead. That means closure creation
891and memory usage is not included in the figures. 897and memory usage is not included in the figures.
892 898
893I<invoke> is the time, in microseconds, used to invoke a simple 899I<invoke> is the time, in microseconds, used to invoke a simple
894callback. The callback simply counts down a Perl variable and after it was 900callback. The callback simply counts down a Perl variable and after it was
895invoked "watcher" times, it would C<< ->broadcast >> a condvar once. 901invoked "watcher" times, it would C<< ->broadcast >> a condvar once to
902signal the end of this phase.
896 903
897I<destroy> is the time, in microseconds, that it takes destroy a single 904I<destroy> is the time, in microseconds, that it takes to destroy a single
898watcher. 905watcher.
899 906
900=head2 Results 907=head2 Results
901 908
902 name watcher bytes create invoke destroy comment 909 name watchers bytes create invoke destroy comment
903 EV/EV 400000 244 0.56 0.46 0.31 EV native interface 910 EV/EV 400000 244 0.56 0.46 0.31 EV native interface
904 EV/Any 100000 610 3.52 0.91 0.75 911 EV/Any 100000 610 3.52 0.91 0.75 EV + AnyEvent watchers
905 CoroEV/Any 100000 610 3.49 0.92 0.75 coroutines + Coro::Signal 912 CoroEV/Any 100000 610 3.49 0.92 0.75 coroutines + Coro::Signal
906 Perl/Any 10000 654 4.64 1.22 0.77 pure perl implementation 913 Perl/Any 100000 513 4.91 0.92 1.15 pure perl implementation
907 Event/Event 10000 523 28.05 21.38 5.22 Event native interface 914 Event/Event 16000 523 28.05 21.38 0.86 Event native interface
908 Event/Any 10000 943 34.43 20.48 1.39 915 Event/Any 16000 943 34.43 20.48 1.39 Event + AnyEvent watchers
909 Glib/Any 16000 1357 96.99 12.55 55.51 quadratic behaviour 916 Glib/Any 16000 1357 96.99 12.55 55.51 quadratic behaviour
910 Tk/Any 2000 1855 27.01 66.61 14.03 SEGV with >> 2000 watchers 917 Tk/Any 2000 1855 27.01 66.61 14.03 SEGV with >> 2000 watchers
918 POE/Event 2000 6644 108.15 768.19 14.33 via POE::Loop::Event
911 POE/Select 2000 6343 94.69 807.65 562.69 POE::Loop::Select 919 POE/Select 2000 6343 94.69 807.65 562.69 via POE::Loop::Select
912 POE/Event 2000 6644 108.15 768.19 14.33 POE::Loop::Event
913 920
914=head2 Discussion 921=head2 Discussion
915 922
916The benchmark does I<not> measure scalability of the event loop very 923The benchmark does I<not> measure scalability of the event loop very
917well. For example, a select-based event loop (such as the pure perl one) 924well. For example, a select-based event loop (such as the pure perl one)
… …
919file descriptors grows high. In this benchmark, only a single filehandle 926file descriptors grows high. In this benchmark, only a single filehandle
920is used (although some of the AnyEvent adaptors dup() its file descriptor 927is used (although some of the AnyEvent adaptors dup() its file descriptor
921to worka round bugs). 928to worka round bugs).
922 929
923C<EV> is the sole leader regarding speed and memory use, which are both 930C<EV> is the sole leader regarding speed and memory use, which are both
924maximal/minimal, respectively. Even when going through AnyEvent, there is 931maximal/minimal, respectively. Even when going through AnyEvent, there are
925only one event loop that uses less memory (the C<Event> module natively), and 932only two event loops that use slightly less memory (the C<Event> module
926no faster event model, not event C<Event> natively. 933natively and the pure perl backend), and no faster event models, not even
934C<Event> natively.
927 935
928The pure perl implementation is hit in a few sweet spots (both the 936The pure perl implementation is hit in a few sweet spots (both the
929zero timeout and the use of a single fd hit optimisations in the perl 937zero timeout and the use of a single fd hit optimisations in the perl
930interpreter and the backend itself). Nevertheless tis shows that it 938interpreter and the backend itself, and all watchers become ready at the
931adds very little overhead in itself. Like any select-based backend its 939same time). Nevertheless this shows that it adds very little overhead in
932performance becomes really bad with lots of file descriptors, of course, 940itself. Like any select-based backend its performance becomes really bad
941with lots of file descriptors (and few of them active), of course, but
933but this was not subjetc of this benchmark. 942this was not subject of this benchmark.
934 943
935The C<Event> module has a relatively high setup and callback invocation cost, 944The C<Event> module has a relatively high setup and callback invocation cost,
936but overall scores on the third place. 945but overall scores on the third place.
937 946
938C<Glib>'s memory usage is quite a bit bit higher, features a faster 947C<Glib>'s memory usage is quite a bit bit higher, but it features a
939callback invocation and overall lands in the same class as C<Event>. 948faster callback invocation and overall ends up in the same class as
949C<Event>. However, Glib scales extremely badly, doubling the number of
950watchers increases the processing time by more than a factor of four,
951making it completely unusable when using larger numbers of watchers
952(note that only a single file descriptor was used in the benchmark, so
953inefficiencies of C<poll> do not account for this).
940 954
941The C<Tk> adaptor works relatively well, the fact that it crashes with 955The C<Tk> adaptor works relatively well. The fact that it crashes with
942more than 2000 watchers is a big setback, however, as correctness takes 956more than 2000 watchers is a big setback, however, as correctness takes
943precedence over speed. Nevertheless, its performance is surprising, as the 957precedence over speed. Nevertheless, its performance is surprising, as the
944file descriptor is dup()ed for each watcher. This shows that the dup() 958file descriptor is dup()ed for each watcher. This shows that the dup()
945employed by some adaptors is not a big performance issue (it does incur a 959employed by some adaptors is not a big performance issue (it does incur a
946hidden memory cost inside the kernel, though). 960hidden memory cost inside the kernel, though, that is not reflected in the
961figures above).
947 962
948C<POE>, regardless of backend (wether using its pure perl select-based 963C<POE>, regardless of underlying event loop (wether using its pure perl
949backend or the Event backend) shows abysmal performance and memory 964select-based backend or the Event module) shows abysmal performance and
950usage: Watchers use almost 30 times as much memory as EV watchers, and 10 965memory usage: Watchers use almost 30 times as much memory as EV watchers,
951times as much memory as both Event or EV via AnyEvent. Watcher invocation 966and 10 times as much memory as both Event or EV via AnyEvent. Watcher
952is almost 700 times slower as with AnyEvent's pure perl implementation. 967invocation is almost 700 times slower than with AnyEvent's pure perl
968implementation. The design of the POE adaptor class in AnyEvent can not
969really account for this, as session creation overhead is small compared
970to execution of the state machine, which is coded pretty optimally within
971L<AnyEvent::Impl::POE>. POE simply seems to be abysmally slow.
953 972
973=head2 Summary
974
954Summary: using EV through AnyEvent is faster than any other event 975Using EV through AnyEvent is faster than any other event loop, but most
955loop. The overhead AnyEvent adds can be very small, and you should avoid 976event loops have acceptable performance with or without AnyEvent.
956POE like the plague if you want performance or reasonable memory usage. 977
978The overhead AnyEvent adds is usually much smaller than the overhead of
979the actual event loop, only with extremely fast event loops such as the EV
980adds AnyEvent significant overhead.
981
982And you should simply avoid POE like the plague if you want performance or
983reasonable memory usage.
957 984
958 985
959=head1 FORK 986=head1 FORK
960 987
961Most event libraries are not fork-safe. The ones who are usually are 988Most event libraries are not fork-safe. The ones who are usually are

Diff Legend

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