[ViewVC] Diff of: cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.392 by root, Fri Apr 29 15:43:27 2011 UTC vs.
Revision 1.396 by root, Fri May 6 18:01:13 2011 UTC

   int valgrind_id;
 #endif
   unsigned char flags;
 } coro_cctx;
-coro_cctx *cctx_current; /* the currently running cctx */
+static coro_cctx *cctx_current; /* the currently running cctx */
 /*****************************************************************************/
 enum {
   CF_RUNNING   = 0x0001, /* coroutine is running */
   CF_READY     = 0x0002, /* coroutine is ready */
   CF_NEW       = 0x0004, /* has never been switched to */
   CF_DESTROYED = 0x0008, /* coroutine data has been freed */
   CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */
+  CF_NOCANCEL  = 0x0020, /* cannot cancel, set slf_frame.data to 1 (hackish) */
 };
 /* the structure where most of the perl state is stored, overlaid on the cxstack */
 typedef struct
 {
 typedef struct coro *Coro__State;
 typedef struct coro *Coro__State_or_hashref;
 /* the following variables are effectively part of the perl context */
 /* and get copied between struct coro and these variables */
-/* the mainr easonw e don't support windows process emulation */
+/* the main reason we don't support windows process emulation */
 static struct CoroSLF slf_frame; /* the current slf frame */
 /** Coro ********************************************************************/
 #define CORO_PRIO_MAX     3
     struct coro *current = SvSTATE_current;
     assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
     save_perl (aTHX_ current);
+    SvRV_set (coro_current, (SV *)coro->hv); /* this will cause acroak in transfer_check */
     load_perl (aTHX_ coro);
     coro_unwind_stacks (aTHX);
     coro_destruct_stacks (aTHX);
     svf    [6] = (SV *)GvHV (PL_hintgv);
     svf    [7] =       PL_diehook;
     svf    [8] =       PL_warnhook;
     assert (9 == sizeof (svf) / sizeof (*svf));
+    SvRV_set (coro_current, (SV *)current->hv);
     load_perl (aTHX_ current);
   }
   {
     unsigned int i;
 cctx_destroy (coro_cctx *cctx)
 {
   if (!cctx)
     return;
-  assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));//D temporary?
+  assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));
   --cctx_count;
   coro_destroy (&cctx->cctx);
   /* coro_transfer creates new, empty cctx's */
 #define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
 #define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
 /** high level stuff ********************************************************/
-static int
+static void
 coro_state_destroy (pTHX_ struct coro *coro)
 {
   if (coro->flags & CF_DESTROYED)
-    return 0;
+    return;
+  /* this callback is reserved for slf functions needing to do cleanup */
   if (coro->on_destroy && !PL_dirty)
     coro->on_destroy (aTHX_ coro);
+  /*
+   * The on_destroy above most likely is from an SLF call.
+   * Since by definition the SLF call will not finish when we destroy
+   * the coro, we will have to force-finish it here, otherwise
+   * cleanup functions cannot call SLF functions.
+   */
+  coro->slf_frame.prepare = 0;
   coro->flags |= CF_DESTROYED;
   if (coro->flags & CF_READY)
     {
   cctx_destroy (coro->cctx);
   SvREFCNT_dec (coro->startcv);
   SvREFCNT_dec (coro->args);
   SvREFCNT_dec (coro->swap_sv);
   SvREFCNT_dec (CORO_THROW);
-  return 1;
 }
 static int
 coro_state_free (pTHX_ SV *sv, MAGIC *mg)
 {
   coro = SvSTATE (arg [0]);
   coro_hv = coro->hv;
   coro_set_status (coro_hv, arg + 1, items - 1);
+  if (expect_false (coro->flags & CF_NOCANCEL))
+    {
+      /* coro currently busy cancelling something, so just notify it */
+      coro->slf_frame.data = (void *)coro;
+      frame->prepare = prepare_nop;
+      frame->check   = slf_check_nop;
+    }
+  else if (coro_hv == (HV *)SvRV (coro_current))
+    {
-  /* cancelling the current coro is allowed, and equals terminate */
+      /* cancelling the current coro is allowed, and equals terminate */
-  if (coro_hv == (HV *)SvRV (coro_current))
-    slf_init_terminate_cancel_common (frame, coro_hv);
+      slf_init_terminate_cancel_common (frame, coro_hv);
+    }
   else
     {
-      /* otherwise we cancel ourselves */
+      struct coro *self = SvSTATE_current;
+      /* otherwise we cancel directly, purely for speed reasons
+       * unfortunately, this requires some magic trickery, as
+       * somebody else could cancel us, so we have to fight the cancellation.
+       * this is ugly, and hopefully fully worth the extra speed.
+       * besides, I can't get the slow-but-safe version working...
+       */
+      slf_frame.data = 0;
+      self->flags |= CF_NOCANCEL;
       coro_state_destroy (aTHX_ coro);
       coro_call_on_destroy (aTHX_ coro);
+      self->flags &= ~CF_NOCANCEL;
+      if (slf_frame.data)
+        {
+          /* while we were busy we have been cancelled, so terminate */
+          slf_init_terminate_cancel_common (frame, self->hv);
+        }
+      else
+        {
-      frame->prepare = prepare_nop;
+          frame->prepare = prepare_nop;
-      frame->check   = slf_check_nop;
+          frame->check   = slf_check_nop;
+        }
     }
 }
 /*****************************************************************************/
 /* async pool handler */
 	CODE:
 {
         if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
           {
             struct coro *current = SvSTATE_current;
+            struct CoroSLF slf_save;
             if (current != coro)
               {
                 PUTBACK;
                 save_perl (aTHX_ current);
                 load_perl (aTHX_ coro);
+                /* the coro is most likely in an active SLF call.
+                 * while not strictly required (the code we execute is
+                 * not allowed to call any SLF functions), it's cleaner
+                 * to reinitialise the slf_frame and restore it later.
+                 * This might one day allow us to actually do SLF calls
+                 * from code executed here.
+                 */
+                slf_save = slf_frame;
+                slf_frame.prepare = 0;
                 SPAGAIN;
               }
             PUSHSTACK;
             SPAGAIN;
             if (current != coro)
               {
                 PUTBACK;
+                slf_frame = slf_save;
                 save_perl (aTHX_ coro);
                 load_perl (aTHX_ current);
                 SPAGAIN;
               }
           }

Diff Legend

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

Comparing Coro/Coro/State.xs (file contents): Revision 1.392 by root, Fri Apr 29 15:43:27 2011 UTC vs. Revision 1.396 by root, Fri May 6 18:01:13 2011 UTC

Diff Legend

Comparing Coro/Coro/State.xs (file contents):
Revision 1.392 by root, Fri Apr 29 15:43:27 2011 UTC vs.
Revision 1.396 by root, Fri May 6 18:01:13 2011 UTC