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

Comparing Coro/Coro/State.xs (file contents):
Revision 1.256 by root, Sat Nov 8 13:32:18 2008 UTC vs.
Revision 1.261 by root, Mon Nov 10 05:09:30 2008 UTC

 static struct CoroAPI coroapi;
 static AV *main_mainstack; /* used to differentiate between $main and others */
 static JMPENV *main_top_env;
 static HV *coro_state_stash, *coro_stash;
 static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */
+static volatile struct coro *transfer_next;
+struct transfer_args
+{
+  struct coro *prev, *next;
+};
 static GV *irsgv;    /* $/ */
 static GV *stdoutgv; /* *STDOUT */
 static SV *rv_diehook;
 static SV *rv_warnhook;
 #define PRIO_MIN    -4
 /* for Coro.pm */
 static SV *coro_current;
 static SV *coro_readyhook;
-static AV *coro_ready [PRIO_MAX-PRIO_MIN+1];
+static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1];
 static int coro_nready;
 static struct coro *coro_first;
 /** lowlevel stuff **********************************************************/
   PL_rs              = newSVsv (GvSV (irsgv));
   PL_defoutgv        = (GV *)SvREFCNT_inc_NN (stdoutgv);
   {
     dSP;
-    LOGOP myop;
+    UNOP myop;
-    Zero (&myop, 1, LOGOP);
+    Zero (&myop, 1, UNOP);
     myop.op_next = Nullop;
     myop.op_flags = OPf_WANT_VOID;
     PUSHMARK (SP);
     XPUSHs (sv_2mortal (av_shift (GvAV (PL_defgv))));
     SPAGAIN;
   }
   /* this newly created coroutine might be run on an existing cctx which most
    * likely was suspended in set_stacklevel, called from entersub.
-   * set_stacklevl doesn't do anything on return, but entersub does LEAVE,
+   * set_stacklevel doesn't do anything on return, but entersub does LEAVE,
-   * so we ENTER here for symmetry
+   * so we ENTER here for symmetry.
    */
   ENTER;
 }
 static void
   TAINT_NOT;
   return 0;
 }
+static void
+prepare_set_stacklevel (struct transfer_args *ta, struct coro_cctx *cctx)
+{
+  ta->prev  = (struct coro *)cctx;
+  ta->next  = 0;
+}
 /* inject a fake call to Coro::State::_cctx_init into the execution */
 /* _cctx_init should be careful, as it could be called at almost any time */
 /* during execution of a perl program */
+/* also initialises PL_top_env */
 static void NOINLINE
 cctx_prepare (pTHX_ coro_cctx *cctx)
 {
   dSP;
-  LOGOP myop;
+  UNOP myop;
   PL_top_env = &PL_start_env;
   if (cctx->flags & CC_TRACE)
     PL_runops = runops_trace;
-  Zero (&myop, 1, LOGOP);
+  Zero (&myop, 1, UNOP);
-  myop.op_next = PL_op;
+  myop.op_next  = PL_op;
   myop.op_flags = OPf_WANT_VOID | OPf_STACKED;
   PUSHMARK (SP);
   EXTEND (SP, 2);
-  PUSHs (sv_2mortal (newSViv (PTR2IV (cctx))));
+  PUSHs (sv_2mortal (newSViv ((IV)cctx)));
   PUSHs ((SV *)get_cv ("Coro::State::_cctx_init", FALSE));
   PUTBACK;
   PL_op = (OP *)&myop;
   PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
   SPAGAIN;
 }
+/* the tail of transfer: execute stuff we can onyl do afetr a transfer */
+static void
+transfer_tail (void)
+{
+  struct coro *next = (struct coro *)transfer_next;
+  transfer_next = 0; //D for temporary assertion in transfer
+  assert (("FATAL ERROR: internal error 1067 in Coro module, please report", next));//D
+  free_coro_mortal (aTHX);
+  UNLOCK;
+  if (expect_false (next->throw))
+    {
+      SV *exception = sv_2mortal (next->throw);
+      next->throw = 0;
+      sv_setsv (ERRSV, exception);
+      croak (0);
+    }
+}
 /*
  * this is a _very_ stripped down perl interpreter ;)
  */
 static void
 cctx_run (void *arg)
 # endif
 #endif
   {
     dTHX;
-    /* cctx_run is the alternative tail of transfer(), so unlock here. */
+    /* entersub called ENTER, but we never 'returned', undo that here */
-    UNLOCK;
+    LEAVE;
-    /* we now skip the entersub that lead to transfer() */
+    /* we now skip the entersub that did lead to transfer() */
     PL_op = PL_op->op_next;
     /* inject a fake subroutine call to cctx_init */
     cctx_prepare (aTHX_ (coro_cctx *)arg);
+    /* cctx_run is the alternative tail of transfer() */
+    transfer_tail ();
     /* somebody or something will hit me for both perl_run and PL_restartop */
     PL_restartop = PL_op;
     perl_run (PL_curinterp);
 static coro_cctx *
 cctx_new ()
 {
   coro_cctx *cctx;
+  ++cctx_count;
+  New (0, cctx, 1, coro_cctx);
+  cctx->gen     = cctx_gen;
+  cctx->flags   = 0;
+  cctx->idle_sp = 0; /* can be accessed by transfer between cctx_run and set_stacklevel, on throw */
+  return cctx;
+}
+/* create a new cctx only suitable as source */
+static coro_cctx *
+cctx_new_empty ()
+{
+  coro_cctx *cctx = cctx_new ();
+  cctx->sptr = 0;
+  coro_create (&cctx->cctx, 0, 0, 0, 0);
+  return cctx;
+}
+/* create a new cctx suitable as destination/running a perl interpreter */
+static coro_cctx *
+cctx_new_run ()
+{
+  coro_cctx *cctx = cctx_new ();
   void *stack_start;
   size_t stack_size;
-  ++cctx_count;
-  Newz (0, cctx, 1, coro_cctx);
-  cctx->gen = cctx_gen;
 #if HAVE_MMAP
   cctx->ssize = ((cctx_stacksize * sizeof (long) + PAGESIZE - 1) / PAGESIZE + CORO_STACKGUARD) * PAGESIZE;
   /* mmap supposedly does allocate-on-write for us */
   cctx->sptr = mmap (0, cctx->ssize, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
         return cctx;
       cctx_destroy (cctx);
     }
-  return cctx_new ();
+  return cctx_new_run ();
 }
 static void
 cctx_put (coro_cctx *cctx)
 {
       ((coro_cctx *)prev)->idle_sp = STACKLEVEL;
       assert (((coro_cctx *)prev)->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */
     }
   else if (expect_true (prev != next))
     {
-      static volatile int has_throw;
       coro_cctx *prev__cctx;
       if (expect_false (prev->flags & CF_NEW))
         {
           /* create a new empty/source context */
-          ++cctx_count;
+          prev->cctx = cctx_new_empty ();
-          New (0, prev->cctx, 1, coro_cctx);
-          prev->cctx->sptr = 0;
-          coro_create (&prev->cctx->cctx, 0, 0, 0, 0);
           prev->flags &= ~CF_NEW;
           prev->flags |=  CF_RUNNING;
         }
       prev->flags &= ~CF_RUNNING;
       else
         load_perl (aTHX_ next);
       prev__cctx = prev->cctx;
-      /* possibly "free" the cctx */
+      /* possibly untie and reuse the cctx */
       if (expect_true (
             prev__cctx->idle_sp == STACKLEVEL
             && !(prev__cctx->flags & CC_TRACE)
             && !force_cctx
          ))
       ++next->usecount;
       if (expect_true (!next->cctx))
         next->cctx = cctx_get (aTHX);
-      has_throw = !!next->throw;
+      assert (("FATAL ERROR: internal error 1352 in Coro, please report", !transfer_next));//D
+      transfer_next = next;
       if (expect_false (prev__cctx != next->cctx))
         {
           prev__cctx->top_env = PL_top_env;
           PL_top_env = next->cctx->top_env;
           coro_transfer (&prev__cctx->cctx, &next->cctx->cctx);
         }
-      free_coro_mortal (aTHX);
+      transfer_tail ();
-      UNLOCK;
-      if (expect_false (has_throw))
-        {
-          struct coro *coro = SvSTATE (coro_current);
-          if (coro->throw)
-            {
-              SV *exception = coro->throw;
-              coro->throw = 0;
-              sv_setsv (ERRSV, exception);
-              croak (0);
-            }
-        }
     }
 }
-struct transfer_args
-{
-  struct coro *prev, *next;
-};
 #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 ********************************************************/
       /* cannot transfer to destroyed coros, skip and look for next */
       if (expect_false (ta->next->flags & CF_DESTROYED))
         {
           UNLOCK;
           SvREFCNT_dec (next_sv);
-          /* coro_nready is already taken care of by destroy */
+          /* coro_nready has already been taken care of by destroy */
           continue;
         }
       --coro_nready;
       UNLOCK;
   struct coro *coro = SvSTATE (coro_sv);
   if (flags & CC_TRACE)
     {
       if (!coro->cctx)
-        coro->cctx = cctx_new ();
+        coro->cctx = cctx_new_run ();
       else if (!(coro->cctx->flags & CC_TRACE))
         croak ("cannot enable tracing on coroutine with custom stack");
       coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL));
     }
         PUTBACK;
         switch (ix)
           {
             case 0:
-              ta.prev  = (struct coro *)INT2PTR (coro_cctx *, SvIV (ST (0)));
+              prepare_set_stacklevel (&ta, (struct coro_cctx *)SvIV (ST (0)));
-              ta.next  = 0;
               break;
             case 1:
               if (items != 2)
                 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d", items);
         is_destroyed = CF_DESTROYED
 	CODE:
         RETVAL = boolSV (coro->flags & ix);
 	OUTPUT:
         RETVAL
+void
+throw (Coro::State self, SV *throw = &PL_sv_undef)
+	PROTOTYPE: $;$
+        CODE:
+        SvREFCNT_dec (self->throw);
+        self->throw = SvOK (throw) ? newSVsv (throw) : 0;
 void
 api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
 SV *
         CODE:
         RETVAL = coro_nready;
 	OUTPUT:
         RETVAL
-void
-throw (Coro::State self, SV *throw = &PL_sv_undef)
-	PROTOTYPE: $;$
-        CODE:
-        SvREFCNT_dec (self->throw);
-        self->throw = SvOK (throw) ? newSVsv (throw) : 0;
 # for async_pool speedup
 void
 _pool_1 (SV *cb)
 	CODE:
 {

Diff Legend

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

Comparing Coro/Coro/State.xs (file contents): Revision 1.256 by root, Sat Nov 8 13:32:18 2008 UTC vs. Revision 1.261 by root, Mon Nov 10 05:09:30 2008 UTC

Diff Legend

Comparing Coro/Coro/State.xs (file contents):
Revision 1.256 by root, Sat Nov 8 13:32:18 2008 UTC vs.
Revision 1.261 by root, Mon Nov 10 05:09:30 2008 UTC