--- AnyEvent/lib/AnyEvent.pm	2008/04/25 07:14:33	1.68
+++ AnyEvent/lib/AnyEvent.pm	2008/04/25 07:43:25	1.72
@@ -866,13 +866,14 @@
 =head1 BENCHMARK
 
 To give you an idea of the performance and overheads that AnyEvent adds
-over the event loops directly, here is a benchmark of various supported
+over the event loops themselves (and to give you an impression of the
+speed of various event loops), here is a benchmark of various supported
 event models natively and with anyevent. The benchmark creates a lot of
 timers (with a zero timeout) and io watchers (watching STDOUT, a pty, to
 become writable, which it is), lets them fire exactly once and destroys
 them again.
 
-=head2 Explanation of the fields
+=head2 Explanation of the columns
 
 I<watcher> is the number of event watchers created/destroyed. Since
 different event models feature vastly different performances, each event
@@ -892,24 +893,25 @@
 
 I<invoke> is the time, in microseconds, used to invoke a simple
 callback. The callback simply counts down a Perl variable and after it was
-invoked "watcher" times, it would C<< ->broadcast >> a condvar once.
+invoked "watcher" times, it would C<< ->broadcast >> a condvar once to
+signal the end of this phase.
 
-I<destroy> is the time, in microseconds, that it takes destroy a single
+I<destroy> is the time, in microseconds, that it takes to destroy a single
 watcher.
 
 =head2 Results
 
           name watcher bytes create invoke destroy comment
          EV/EV  400000   244   0.56   0.46    0.31 EV native interface
-        EV/Any  100000   610   3.52   0.91    0.75 
+        EV/Any  100000   610   3.52   0.91    0.75 EV + AnyEvent watchers
     CoroEV/Any  100000   610   3.49   0.92    0.75 coroutines + Coro::Signal
-      Perl/Any   10000   654   4.64   1.22    0.77 pure perl implementation
-   Event/Event   10000   523  28.05  21.38    5.22 Event native interface
-     Event/Any   10000   943  34.43  20.48    1.39
+      Perl/Any   16000   654   4.64   1.22    0.77 pure perl implementation
+   Event/Event   16000   523  28.05  21.38    0.86 Event native interface
+     Event/Any   16000   943  34.43  20.48    1.39 Event + AnyEvent watchers
       Glib/Any   16000  1357  96.99  12.55   55.51 quadratic behaviour
         Tk/Any    2000  1855  27.01  66.61   14.03 SEGV with >> 2000 watchers
-    POE/Select    2000  6343  94.69 807.65  562.69 POE::Loop::Select
-     POE/Event    2000  6644 108.15 768.19   14.33 POE::Loop::Event
+     POE/Event    2000  6644 108.15 768.19   14.33 via POE::Loop::Event
+    POE/Select    2000  6343  94.69 807.65  562.69 via POE::Loop::Select
 
 =head2 Discussion
 
@@ -945,15 +947,27 @@
 employed by some adaptors is not a big performance issue (it does incur a
 hidden memory cost inside the kernel, though).
 
-C<POE>, regardless of backend (wether using its pure perl select-based
-backend or the Event backend) shows abysmal performance and memory
-usage: Watchers use almost 30 times as much memory as EV watchers, and 10
-times as much memory as both Event or EV via AnyEvent. Watcher invocation
-is almost 700 times slower as with AnyEvent's pure perl implementation.
-
-Summary: using EV through AnyEvent is faster than any other event
-loop. The overhead AnyEvent adds can be very small, and you should avoid
-POE like the plague if you want performance or reasonable memory usage.
+C<POE>, regardless of underlying event loop (wether using its pure perl
+select-based backend or the Event module) shows abysmal performance and
+memory usage: Watchers use almost 30 times as much memory as EV watchers,
+and 10 times as much memory as both Event or EV via AnyEvent. Watcher
+invocation is almost 700 times slower than with AnyEvent's pure perl
+implementation. The design of the POE adaptor class in AnyEvent can not
+really account for this, as session creation overhead is small compared
+to execution of the state machine, which is coded pretty optimally within
+L<AnyEvent::Impl::POE>. POE simply seems to be abysmally slow.
+
+=head2 Summary
+
+Using EV through AnyEvent is faster than any other event loop, but most
+event loops have acceptable performance with or without AnyEvent.
+
+The overhead AnyEvent adds is usually much smaller than the overhead of
+the actual event loop, only with extremely fast event loops such as the EV
+adds Anyevent significant overhead.
+
+And you should simply avoid POE like the plague if you want performance or
+reasonable memory usage.
 
 
 =head1 FORK