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

Comparing Coro/Coro/State.xs (file contents):
Revision 1.258 by root, Sun Nov 9 23:08:49 2008 UTC vs.
Revision 1.263 by root, Wed Nov 12 04:49:06 2008 UTC

 # define BOOT_PAGESIZE (void)0
 #endif
 #if CORO_USE_VALGRIND
 # include <valgrind/valgrind.h>
-# define REGISTER_STACK(cctx,start,end) (cctx)->valgrind_id = VALGRIND_STACK_REGISTER ((start), (end))
-#else
-# define REGISTER_STACK(cctx,start,end)
 #endif
 /* the maximum number of idle cctx that will be pooled */
 static int cctx_max_idle = 4;
 #if __GNUC__ >= 3
 # define attribute(x) __attribute__(x)
 # define BARRIER __asm__ __volatile__ ("" : : : "memory")
 # define expect(expr,value) __builtin_expect ((expr),(value))
+# define INLINE static inline
 #else
 # define attribute(x)
 # define BARRIER
 # define expect(expr,value) (expr)
+# define INLINE static
 #endif
 #define expect_false(expr) expect ((expr) != 0, 0)
 #define expect_true(expr)  expect ((expr) != 0, 1)
 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;
     : 0
 #define CORO_MAGIC_cv(cv)    CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)
 #define CORO_MAGIC_state(sv) CORO_MAGIC (((SV *)(sv)), CORO_MAGIC_type_state)
-static struct coro *
+INLINE struct coro *
 SvSTATE_ (pTHX_ SV *coro)
 {
   HV *stash;
   MAGIC *mg;
 #define MgPV_nolen_const(mg)    (((((int)(mg)->mg_len)) == HEf_SVKEY) ?   \
                                  SvPV_nolen((SV*)((mg)->mg_ptr)) :  \
                                  (const char*)(mg)->mg_ptr)
 #endif
+/* we sometimes need to create the effect of entersub calling us */
+#define ENTERSUB_HEAD ENTER; SAVETMPS
+/* we somtimes need to create the effect of leaving via entersub */
+#define ENTERSUB_TAIL LEAVE
 /*
  * This overrides the default magic get method of %SIG elements.
  * The original one doesn't provide for reading back of PL_diehook/PL_warnhook
  * and instead of tryign to save and restore the hash elements, we just provide
  * readback here.
   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;
+  ENTERSUB_HEAD;
 }
 static void
 coro_destruct (pTHX_ struct coro *coro)
 {
   SvREFCNT_dec (coro->throw);
   coro_destruct_stacks (aTHX);
 }
-static void
+INLINE void
 free_coro_mortal (pTHX)
 {
   if (expect_true (coro_mortal))
     {
       SvREFCNT_dec (coro_mortal);
   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 only do after a transfer */
+INLINE void
+transfer_tail (pTHX)
+{
+  struct coro *next = (struct coro *)transfer_next;
+  assert (!(transfer_next = 0)); /* just used for the side effect when asserts are enabled */
+  assert (("FATAL: transfer_next was zero in transfer_tail (please report)", next));
+  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;
+    ENTERSUB_TAIL;
-    /* 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 (aTHX);
     /* somebody or something will hit me for both perl_run and PL_restartop */
     PL_restartop = PL_op;
     perl_run (PL_curinterp);
   coro_cctx *cctx;
   ++cctx_count;
   New (0, cctx, 1, coro_cctx);
-  cctx->gen   = cctx_gen;
+  cctx->gen     = cctx_gen;
-  cctx->flags = 0;
+  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;
+  cctx->sptr = 0;
-  cctx->idle_sp = 0; /* should never be a valid address */
   coro_create (&cctx->cctx, 0, 0, 0, 0);
   return cctx;
 }
   /* 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);
   if (cctx->sptr != (void *)-1)
     {
-# if CORO_STACKGUARD
+      #if CORO_STACKGUARD
-      mprotect (cctx->sptr, CORO_STACKGUARD * PAGESIZE, PROT_NONE);
+        mprotect (cctx->sptr, CORO_STACKGUARD * PAGESIZE, PROT_NONE);
-# endif
+      #endif
-      stack_start = CORO_STACKGUARD * PAGESIZE + (char *)cctx->sptr;
+      stack_start = (char *)cctx->sptr + CORO_STACKGUARD * PAGESIZE;
-      stack_size  = cctx->ssize - CORO_STACKGUARD * PAGESIZE;
+      stack_size  = cctx->ssize        - CORO_STACKGUARD * PAGESIZE;
       cctx->flags |= CC_MAPPED;
     }
   else
 #endif
     {
       stack_start = cctx->sptr;
       stack_size  = cctx->ssize;
     }
-  REGISTER_STACK (cctx, (char *)stack_start, (char *)stack_start + stack_size);
+  #if CORO_USE_VALGRIND
+    cctx->valgrind_id = VALGRIND_STACK_REGISTER ((char *)stack_start, (char *)stack_start + stack_size);
+  #endif
   coro_create (&cctx->cctx, cctx_run, (void *)cctx, stack_start, stack_size);
   return cctx;
 }
   coro_destroy (&cctx->cctx);
   /* coro_transfer creates new, empty cctx's */
   if (cctx->sptr)
     {
-#if CORO_USE_VALGRIND
+      #if CORO_USE_VALGRIND
-      VALGRIND_STACK_DEREGISTER (cctx->valgrind_id);
+        VALGRIND_STACK_DEREGISTER (cctx->valgrind_id);
-#endif
+      #endif
 #if HAVE_MMAP
       if (cctx->flags & CC_MAPPED)
         munmap (cctx->sptr, cctx->ssize);
       else
 }
 static void
 cctx_put (coro_cctx *cctx)
 {
-  assert (("cctx_put called on non-initialised cctx", cctx->sptr));
+  assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));
   /* free another cctx if overlimit */
   if (expect_false (cctx_idle >= cctx_max_idle))
     {
       coro_cctx *first = cctx_first;
       ((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 */
       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
          ))
         {
           /* I assume that STACKLEVEL is a stronger indicator than PL_top_env changes */
-          assert (("ERROR: current top_env must equal previous top_env", PL_top_env == prev__cctx->idle_te));
+          assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == prev__cctx->idle_te));
           prev->cctx = 0;
           /* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get */
           /* without this the next cctx_get might destroy the prev__cctx while still in use */
       ++next->usecount;
       if (expect_true (!next->cctx))
         next->cctx = cctx_get (aTHX);
-      has_throw = !!next->throw;
+      assert (("FATAL: transfer_next already nonzero in Coro (please report)", !transfer_next));
+      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 (aTHX);
-      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 ********************************************************/
 static int
 api_is_ready (SV *coro_sv)
 {
   dTHX;
   return !!(SvSTATE (coro_sv)->flags & CF_READY);
 }
-static void
+INLINE void
 prepare_schedule (pTHX_ struct transfer_args *ta)
 {
   SV *prev_sv, *next_sv;
   for (;;)
       /* 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;
   /* free this only after the transfer */
   prev_sv = SvRV (coro_current);
   ta->prev = SvSTATE (prev_sv);
   TRANSFER_CHECK (*ta);
-  assert (ta->next->flags & CF_READY);
+  assert (("FATAL: next coroutine isn't marked as ready in Coro (please report)", ta->next->flags & CF_READY));
   ta->next->flags &= ~CF_READY;
   SvRV_set (coro_current, next_sv);
   LOCK;
   free_coro_mortal (aTHX);
   coro_mortal = prev_sv;
   UNLOCK;
 }
-static void
+INLINE void
 prepare_cede (pTHX_ struct transfer_args *ta)
 {
   api_ready (coro_current);
   prepare_schedule (aTHX_ ta);
 }
         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 *
         for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
           coro_ready[i] = newAV ();
         {
-          SV *sv = perl_get_sv ("Coro::API", TRUE);
+          SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
-                   perl_get_sv ("Coro::API", TRUE); /* silence 5.10 warning */
           coroapi.schedule     = api_schedule;
           coroapi.cede         = api_cede;
           coroapi.cede_notself = api_cede_notself;
           coroapi.ready        = api_ready;
         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:
 {
 MODULE = Coro::State                PACKAGE = PerlIO::cede
 BOOT:
 	PerlIO_define_layer (aTHX_ &PerlIO_cede);

Diff Legend

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

Comparing Coro/Coro/State.xs (file contents): Revision 1.258 by root, Sun Nov 9 23:08:49 2008 UTC vs. Revision 1.263 by root, Wed Nov 12 04:49:06 2008 UTC

Diff Legend

Comparing Coro/Coro/State.xs (file contents):
Revision 1.258 by root, Sun Nov 9 23:08:49 2008 UTC vs.
Revision 1.263 by root, Wed Nov 12 04:49:06 2008 UTC