[ViewVC] Diff of: cvs/Coro/README

Comparing Coro/README (file contents):
Revision 1.33 by root, Tue Mar 4 06:13:24 2014 UTC vs.
Revision 1.40 by root, Thu Aug 31 16:28:49 2017 UTC

         program, as "async" does. As the coro is being reused, stuff like
         "on_destroy" will not work in the expected way, unless you call
         terminate or cancel, which somehow defeats the purpose of pooling
         (but is fine in the exceptional case).
-        The priority will be reset to 0 after each run, tracing will be
+        The priority will be reset to 0 after each run, all "swap_sv" calls
-        disabled, the description will be reset and the default output
+        will be undone, tracing will be disabled, the description will be
-        filehandle gets restored, so you can change all these. Otherwise the
+        reset and the default output filehandle gets restored, so you can
-        coro will be re-used "as-is": most notably if you change other
+        change all these. Otherwise the coro will be re-used "as-is": most
-        per-coro global stuff such as $/ you *must needs* revert that
+        notably if you change other per-coro global stuff such as $/ you
-        change, which is most simply done by using local as in: "local $/".
+        *must needs* revert that change, which is most simply done by using
+        local as in: "local $/".
         The idle pool size is limited to 8 idle coros (this can be adjusted
         by changing $Coro::POOL_SIZE), but there can be as many non-idle
         coros as required.
               # at this place, the timezone is Antarctica/South_Pole,
               # without disturbing the TZ of any other coro.
            };
         This can be used to localise about any resource (locale, uid,
-        current working directory etc.) to a block, despite the existance of
+        current working directory etc.) to a block, despite the existence of
         other coros.
         Another interesting example implements time-sliced multitasking
         using interval timers (this could obviously be optimised, but does
         the job):
     $state->is_new
         Returns true iff this Coro object is "new", i.e. has never been run
         yet. Those states basically consist of only the code reference to
         call and the arguments, but consumes very little other resources.
         New states will automatically get assigned a perl interpreter when
-        they are transfered to.
+        they are transferred to.
     $state->is_zombie
         Returns true iff the Coro object has been cancelled, i.e. it's
         resources freed because they were "cancel"'ed, "terminate"'d,
         "safe_cancel"'ed or simply went out of scope.
     $is_suspended = $coro->is_suspended
         Returns true iff this Coro object has been suspended. Suspended
         Coros will not ever be scheduled.
-    $coro->cancel (arg...)
+    $coro->cancel ($arg...)
-        Terminates the given Coro thread and makes it return the given
+        Terminate the given Coro thread and make it return the given
         arguments as status (default: an empty list). Never returns if the
         Coro is the current Coro.
         This is a rather brutal way to free a coro, with some limitations -
         if the thread is inside a C callback that doesn't expect to be
         canceled, bad things can happen, or if the cancelled thread insists
         on running complicated cleanup handlers that rely on its thread
         context, things will not work.
-        Any cleanup code being run (e.g. from "guard" blocks) will be run
+        Any cleanup code being run (e.g. from "guard" blocks, destructors
-        without a thread context, and is not allowed to switch to other
+        and so on) will be run without a thread context, and is not allowed
+        to switch to other threads. A common mistake is to call "->cancel"
+        from a destructor called by die'ing inside the thread to be
+        cancelled for example.
-        threads. On the plus side, "->cancel" will always clean up the
+        On the plus side, "->cancel" will always clean up the thread, no
-        thread, no matter what. If your cleanup code is complex or you want
+        matter what. If your cleanup code is complex or you want to avoid
-        to avoid cancelling a C-thread that doesn't know how to clean up
+        cancelling a C-thread that doesn't know how to clean up itself, it
-        itself, it can be better to "->throw" an exception, or use
+        can be better to "->throw" an exception, or use "->safe_cancel".
-        "->safe_cancel".
         The arguments to "->cancel" are not copied, but instead will be
         referenced directly (e.g. if you pass $var and after the call change
         that variable, then you might change the return values passed to
         e.g. "join", so don't do that).
         actually destruct the Coro object.
     $coro->safe_cancel ($arg...)
         Works mostly like "->cancel", but is inherently "safer", and
         consequently, can fail with an exception in cases the thread is not
-        in a cancellable state.
+        in a cancellable state. Essentially, "->safe_cancel" is a "->cancel"
+        with extra checks before canceling.
-        This method works a bit like throwing an exception that cannot be
+        It works a bit like throwing an exception that cannot be caught -
-        caught - specifically, it will clean up the thread from within
+        specifically, it will clean up the thread from within itself, so all
-        itself, so all cleanup handlers (e.g. "guard" blocks) are run with
+        cleanup handlers (e.g. "guard" blocks) are run with full thread
-        full thread context and can block if they wish. The downside is that
+        context and can block if they wish. The downside is that there is no
-        there is no guarantee that the thread can be cancelled when you call
+        guarantee that the thread can be cancelled when you call this
-        this method, and therefore, it might fail. It is also considerably
+        method, and therefore, it might fail. It is also considerably slower
-        slower than "cancel" or "terminate".
+        than "cancel" or "terminate".
-        A thread is in a safe-cancellable state if it either hasn't been run
+        A thread is in a safe-cancellable state if it either has never been
+        run yet, has already been canceled/terminated or otherwise
-        yet, or it has no C context attached and is inside an SLF function.
+        destroyed, or has no C context attached and is inside an SLF
+        function.
+        The first two states are trivial - a thread that hasnot started or
+        has already finished is safe to cancel.
-        The latter two basically mean that the thread isn't currently inside
+        The last state basically means that the thread isn't currently
-        a perl callback called from some C function (usually via some XS
+        inside a perl callback called from some C function (usually via some
-        modules) and isn't currently executing inside some C function itself
+        XS modules) and isn't currently executing inside some C function
-        (via Coro's XS API).
+        itself (via Coro's XS API).
         This call returns true when it could cancel the thread, or croaks
         with an error otherwise (i.e. it either returns true or doesn't
         return at all).
         otherwise you might suffer from crashes or worse. The only event
         library currently known that is safe to use without "unblock_sub" is
         EV (but you might still run into deadlocks if all event loops are
         blocked).
-        Coro will try to catch you when you block in the event loop
+        Coro will try to catch you when you block in the event loop ("FATAL:
-        ("FATAL:$Coro::IDLE blocked itself"), but this is just best effort
+        $Coro::idle blocked itself"), but this is just best effort and only
-        and only works when you do not run your own event loop.
+        works when you do not run your own event loop.
         This function allows your callbacks to block by executing them in
         another coro where it is safe to block. One example where blocking
         is handy is when you use the Coro::AIO functions to save results to
         disk, for example.
     It is very common for a coro to wait for some callback to be called.
     This occurs naturally when you use coro in an otherwise event-based
     program, or when you use event-based libraries.
     These typically register a callback for some event, and call that
-    callback when the event occured. In a coro, however, you typically want
+    callback when the event occurred. In a coro, however, you typically want
     to just wait for the event, simplyifying things.
     For example "AnyEvent->child" registers a callback to be called when a
     specific child has exited:
     processes. What makes it so bad is that on non-windows platforms, you
     can actually take advantage of custom hardware for this purpose (as
     evidenced by the forks module, which gives you the (i-) threads API,
     just much faster).
-    Sharing data is in the i-threads model is done by transfering data
+    Sharing data is in the i-threads model is done by transferring data
     structures between threads using copying semantics, which is very slow -
     shared data simply does not exist. Benchmarks using i-threads which are
     communication-intensive show extremely bad behaviour with i-threads (in
     fact, so bad that Coro, which cannot take direct advantage of multiple
     CPUs, is often orders of magnitude faster because it shares data using
     XS API: Coro::MakeMaker.
     Low level Configuration, Thread Environment, Continuations: Coro::State.
-AUTHOR
+AUTHOR/SUPPORT/CONTACT
-     Marc Lehmann <schmorp@schmorp.de>
+       Marc A. Lehmann <schmorp@schmorp.de>
-     http://home.schmorp.de/
+       http://software.schmorp.de/pkg/Coro.html

Diff Legend

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

Comparing Coro/README (file contents): Revision 1.33 by root, Tue Mar 4 06:13:24 2014 UTC vs. Revision 1.40 by root, Thu Aug 31 16:28:49 2017 UTC

Diff Legend

Comparing Coro/README (file contents):
Revision 1.33 by root, Tue Mar 4 06:13:24 2014 UTC vs.
Revision 1.40 by root, Thu Aug 31 16:28:49 2017 UTC