ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Coro/Coro/State.xs
(Generate patch)

Comparing Coro/Coro/State.xs (file contents):
Revision 1.430 by root, Wed Dec 19 23:36:16 2012 UTC vs.
Revision 1.453 by root, Tue Jul 7 00:33:25 2015 UTC

… …
14#include "perliol.h" 14#include "perliol.h"
15 15
16#include "schmorp.h" 16#include "schmorp.h"
17 17
18#define ECB_NO_THREADS 1 18#define ECB_NO_THREADS 1
19#define ECB_NO_LIBM 1
19#include "ecb.h" 20#include "ecb.h"
20 21
21#include <stddef.h> 22#include <stddef.h>
22#include <stdio.h> 23#include <stdio.h>
23#include <errno.h> 24#include <errno.h>
24#include <assert.h> 25#include <assert.h>
25 26
27#ifndef SvREFCNT_dec_NN
28 #define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
29#endif
30
31#ifndef SvREFCNT_inc_NN
32 #define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
33#endif
34
26#ifndef SVs_PADSTALE 35#ifndef SVs_PADSTALE
27# define SVs_PADSTALE 0 36# define SVs_PADSTALE 0
28#endif 37#endif
29 38
30#ifdef PadARRAY 39#ifdef PadARRAY
31# define NEWPADAPI 40# define NEWPADAPI 1
32# define newPADLIST(var) (Newz (0, var, 1, PADLIST), Newx (PadlistARRAY (var), 2, PAD *)) 41# define newPADLIST(var) (Newz (0, var, 1, PADLIST), Newx (PadlistARRAY (var), 2, PAD *))
33#else 42#else
34typedef AV PADNAMELIST; 43typedef AV PADNAMELIST;
35# if !PERL_VERSION_ATLEAST(5,8,0) 44# if !PERL_VERSION_ATLEAST(5,8,0)
36typedef AV PADLIST; 45typedef AV PADLIST;
… …
41# define PadlistNAMES(pl) (*PadlistARRAY (pl)) 50# define PadlistNAMES(pl) (*PadlistARRAY (pl))
42# define PadARRAY AvARRAY 51# define PadARRAY AvARRAY
43# define PadMAX AvFILLp 52# define PadMAX AvFILLp
44# define newPADLIST(var) ((var) = newAV (), av_extend (var, 1)) 53# define newPADLIST(var) ((var) = newAV (), av_extend (var, 1))
45#endif 54#endif
55#ifndef PadnamelistREFCNT
56# define PadnamelistREFCNT(pnl) SvREFCNT (pnl)
57#endif
58#ifndef PadnamelistREFCNT_dec
59# define PadnamelistREFCNT_dec(pnl) SvREFCNT_dec (pnl)
60#endif
61
62/* 5.19.something has replaced SVt_BIND by SVt_INVLIST */
63/* we just alias it to SVt_IV, as that is sufficient for swap_sv for now */
64#if PERL_VERSION_ATLEAST(5,19,0)
65# define SVt_BIND SVt_IV
66#endif
46 67
47#if defined(_WIN32) 68#if defined(_WIN32)
48# undef HAS_GETTIMEOFDAY 69# undef HAS_GETTIMEOFDAY
49# undef setjmp 70# undef setjmp
50# undef longjmp 71# undef longjmp
… …
235 SV *saved_deffh; 256 SV *saved_deffh;
236 SV *invoke_cb; 257 SV *invoke_cb;
237 AV *invoke_av; 258 AV *invoke_av;
238 259
239 /* on_enter/on_leave */ 260 /* on_enter/on_leave */
240 AV *on_enter; 261 AV *on_enter; AV *on_enter_xs;
241 AV *on_leave; 262 AV *on_leave; AV *on_leave_xs;
242 263
243 /* swap_sv */ 264 /* swap_sv */
244 AV *swap_sv; 265 AV *swap_sv;
245 266
246 /* times */ 267 /* times */
… …
482 503
483 return 0; 504 return 0;
484} 505}
485 506
486ecb_inline struct coro * 507ecb_inline struct coro *
487SvSTATE_ (pTHX_ SV *coro) 508SvSTATE_ (pTHX_ SV *coro_sv)
488{ 509{
489 MAGIC *mg; 510 MAGIC *mg;
490 511
491 if (SvROK (coro)) 512 if (SvROK (coro_sv))
492 coro = SvRV (coro); 513 coro_sv = SvRV (coro_sv);
493 514
494 mg = SvSTATEhv_p (aTHX_ coro); 515 mg = SvSTATEhv_p (aTHX_ coro_sv);
495 if (!mg) 516 if (!mg)
496 croak ("Coro::State object required"); 517 croak ("Coro::State object required");
497 518
498 return (struct coro *)mg->mg_ptr; 519 return (struct coro *)mg->mg_ptr;
499} 520}
… …
510ecb_inline PADLIST * 531ecb_inline PADLIST *
511coro_derive_padlist (pTHX_ CV *cv) 532coro_derive_padlist (pTHX_ CV *cv)
512{ 533{
513 PADLIST *padlist = CvPADLIST (cv); 534 PADLIST *padlist = CvPADLIST (cv);
514 PADLIST *newpadlist; 535 PADLIST *newpadlist;
536 PADNAMELIST *padnames;
515 PAD *newpad; 537 PAD *newpad;
516 PADOFFSET const off = PadlistMAX (padlist) + 1; 538 PADOFFSET off = PadlistMAX (padlist) + 1;
517 539
518 newPADLIST(newpadlist); 540#if NEWPADAPI
519#if !PERL_VERSION_ATLEAST(5,15,3) 541
520 /* Padlists are AvREAL as of 5.15.3. See perl bug #98092 and perl commit 7d953ba. */ 542 /* if we had the original CvDEPTH, we might be able to steal the CvDEPTH+1 entry instead */
521 AvREAL_off (newpadlist); 543 /* 20131102194744.GA6705@schmorp.de, 20131102195825.2013.qmail@lists-nntp.develooper.com */
522#endif 544 while (!PadlistARRAY (padlist)[off - 1])
545 --off;
546
547 Perl_pad_push (aTHX_ padlist, off);
548
549 newpad = PadlistARRAY (padlist)[off];
550 PadlistARRAY (padlist)[off] = 0;
551
552#else
553
523#if PERL_VERSION_ATLEAST (5,10,0) 554#if PERL_VERSION_ATLEAST (5,10,0)
524 Perl_pad_push (aTHX_ padlist, off); 555 Perl_pad_push (aTHX_ padlist, off);
525#else 556#else
526 Perl_pad_push (aTHX_ padlist, off, 1); 557 Perl_pad_push (aTHX_ padlist, off, 1);
527#endif 558#endif
559
528 newpad = PadlistARRAY (padlist)[off]; 560 newpad = PadlistARRAY (padlist)[off];
529 PadlistMAX (padlist) = off - 1; 561 PadlistMAX (padlist) = off - 1;
530 562
563#endif
564
565 newPADLIST (newpadlist);
566#if !PERL_VERSION_ATLEAST(5,15,3)
567 /* Padlists are AvREAL as of 5.15.3. See perl bug #98092 and perl commit 7d953ba. */
568 AvREAL_off (newpadlist);
569#endif
570
531 /* Already extended to 2 elements by newPADLIST. */ 571 /* Already extended to 2 elements by newPADLIST. */
532 PadlistMAX (newpadlist) = 1; 572 PadlistMAX (newpadlist) = 1;
533 PadlistNAMES (newpadlist) = (PADNAMELIST *)SvREFCNT_inc_NN (PadlistNAMES (padlist)); 573
574 padnames = PadlistNAMES (padlist);
575 ++PadnamelistREFCNT (padnames);
576 PadlistNAMES (newpadlist) = padnames;
577
534 PadlistARRAY (newpadlist)[1] = newpad; 578 PadlistARRAY (newpadlist)[1] = newpad;
535 579
536 return newpadlist; 580 return newpadlist;
537} 581}
538 582
… …
546 590
547 while (i > 0) /* special-case index 0 */ 591 while (i > 0) /* special-case index 0 */
548 { 592 {
549 /* we try to be extra-careful here */ 593 /* we try to be extra-careful here */
550 PAD *pad = PadlistARRAY (padlist)[i--]; 594 PAD *pad = PadlistARRAY (padlist)[i--];
595
596 if (pad)
597 {
551 I32 j = PadMAX (pad); 598 I32 j = PadMAX (pad);
552 599
553 while (j >= 0) 600 while (j >= 0)
554 SvREFCNT_dec (PadARRAY (pad)[j--]); 601 SvREFCNT_dec (PadARRAY (pad)[j--]);
555 602
556 PadMAX (pad) = -1; 603 PadMAX (pad) = -1;
557 SvREFCNT_dec (pad); 604 SvREFCNT_dec (pad);
605 }
558 } 606 }
559 607
560 SvREFCNT_dec (PadlistNAMES (padlist)); 608 PadnamelistREFCNT_dec (PadlistNAMES (padlist));
561 609
562#ifdef NEWPADAPI 610#if NEWPADAPI
563 Safefree (PadlistARRAY (padlist)); 611 Safefree (PadlistARRAY (padlist));
564 Safefree (padlist); 612 Safefree (padlist);
565#else 613#else
566 AvFILLp (padlist) = -1; 614 AvFILLp (padlist) = -1;
567 AvREAL_off (padlist); 615 AvREAL_off (padlist);
… …
661 tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u; 709 tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u;
662 710
663 /* if SvANY points to the head, we need to adjust the pointers, 711 /* if SvANY points to the head, we need to adjust the pointers,
664 * as the pointer for a still points to b, and maybe vice versa. 712 * as the pointer for a still points to b, and maybe vice versa.
665 */ 713 */
666 #define svany_in_head(type) \ 714 U32 svany_in_head_set = (1 << SVt_NULL) | (1 << SVt_BIND) | (1 << SVt_IV) | (1 << SVt_RV);
667 (((1 << SVt_NULL) | (1 << SVt_BIND) | (1 << SVt_IV) | (1 << SVt_RV)) & (1 << (type))) 715 #if NVSIZE <= IVSIZE && PERL_VERSION_ATLEAST(5,20,0)
716 svany_in_head_set |= 1 << SVt_NV;
717 #endif
718
719 #define svany_in_head(type) (svany_in_head_set & (1 << (type)))
668 720
669 if (svany_in_head (SvTYPE (a))) 721 if (svany_in_head (SvTYPE (a)))
670 SvANY (a) = (void *)((PTRV)SvANY (a) - (PTRV)b + (PTRV)a); 722 SvANY (a) = (void *)((PTRV)SvANY (a) - (PTRV)b + (PTRV)a);
671 723
672 if (svany_in_head (SvTYPE (b))) 724 if (svany_in_head (SvTYPE (b)))
… …
740 792
741 for (i = 0; i <= AvFILLp (c->on_enter); ++i) 793 for (i = 0; i <= AvFILLp (c->on_enter); ++i)
742 on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]); 794 on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);
743 } 795 }
744 796
797 if (ecb_expect_false (c->on_enter_xs))
798 {
799 int i;
800
801 for (i = 0; i <= AvFILLp (c->on_enter_xs); i += 2)
802 ((coro_enterleave_hook)AvARRAY (c->on_enter_xs)[i]) (aTHX_ AvARRAY (c->on_enter_xs)[i + 1]);
803 }
804
745 SWAP_SVS (c); 805 SWAP_SVS (c);
746} 806}
747 807
748static void 808static void
749save_perl (pTHX_ Coro__State c) 809save_perl (pTHX_ Coro__State c)
750{ 810{
751 SWAP_SVS (c); 811 SWAP_SVS (c);
812
813 if (ecb_expect_false (c->on_leave_xs))
814 {
815 int i;
816
817 for (i = AvFILLp (c->on_leave_xs) - 1; i >= 0; i -= 2)
818 ((coro_enterleave_hook)AvARRAY (c->on_leave_xs)[i]) (aTHX_ AvARRAY (c->on_leave_xs)[i + 1]);
819 }
752 820
753 if (ecb_expect_false (c->on_leave)) 821 if (ecb_expect_false (c->on_leave))
754 { 822 {
755 int i; 823 int i;
756 824
… …
1109 1177
1110 GvSV (PL_defgv) = newSV (0); 1178 GvSV (PL_defgv) = newSV (0);
1111 GvAV (PL_defgv) = coro->args; coro->args = 0; 1179 GvAV (PL_defgv) = coro->args; coro->args = 0;
1112 GvSV (PL_errgv) = newSV (0); 1180 GvSV (PL_errgv) = newSV (0);
1113 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0); 1181 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
1114 GvHV (PL_hintgv) = 0; 1182 GvHV (PL_hintgv) = newHV ();
1183#if PERL_VERSION_ATLEAST (5,10,0)
1184 hv_magic (GvHV (PL_hintgv), 0, PERL_MAGIC_hints);
1185#endif
1115 PL_rs = newSVsv (GvSV (irsgv)); 1186 PL_rs = newSVsv (GvSV (irsgv));
1116 PL_defoutgv = (GV *)SvREFCNT_inc_NN (stdoutgv); 1187 PL_defoutgv = (GV *)SvREFCNT_inc_NN (stdoutgv);
1117 1188
1118 { 1189 {
1119 dSP; 1190 dSP;
… …
1229 1300
1230 SvREFCNT_dec (coro->saved_deffh); 1301 SvREFCNT_dec (coro->saved_deffh);
1231 SvREFCNT_dec (coro->rouse_cb); 1302 SvREFCNT_dec (coro->rouse_cb);
1232 SvREFCNT_dec (coro->invoke_cb); 1303 SvREFCNT_dec (coro->invoke_cb);
1233 SvREFCNT_dec (coro->invoke_av); 1304 SvREFCNT_dec (coro->invoke_av);
1305 SvREFCNT_dec (coro->on_enter_xs);
1306 SvREFCNT_dec (coro->on_leave_xs);
1234 } 1307 }
1235} 1308}
1236 1309
1237ecb_inline void 1310ecb_inline void
1238free_coro_mortal (pTHX) 1311free_coro_mortal (pTHX)
… …
1301 1374
1302 if (PL_curcop != &PL_compiling) 1375 if (PL_curcop != &PL_compiling)
1303 { 1376 {
1304 SV **cb; 1377 SV **cb;
1305 1378
1306 if (oldcxix != cxstack_ix && cctx_current->flags & CC_TRACE_SUB) 1379 if (oldcxix != cxstack_ix && cctx_current->flags & CC_TRACE_SUB && cxstack_ix >= 0)
1307 { 1380 {
1308 PERL_CONTEXT *cx = &cxstack[cxstack_ix]; 1381 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
1309 1382
1310 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix) 1383 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix)
1311 { 1384 {
… …
1888 /* nothing to schedule: call the idle handler */ 1961 /* nothing to schedule: call the idle handler */
1889 if (SvROK (sv_idle) 1962 if (SvROK (sv_idle)
1890 && SvOBJECT (SvRV (sv_idle))) 1963 && SvOBJECT (SvRV (sv_idle)))
1891 { 1964 {
1892 if (SvRV (sv_idle) == SvRV (coro_current)) 1965 if (SvRV (sv_idle) == SvRV (coro_current))
1966 {
1967 require_pv ("Carp");
1968
1969 {
1970 dSP;
1971
1972 ENTER;
1973 SAVETMPS;
1974
1975 PUSHMARK (SP);
1893 croak ("FATAL: $Coro::IDLE blocked itself - did you try to block inside an event loop callback? Caught"); 1976 XPUSHs (sv_2mortal (newSVpv ("FATAL: $Coro::idle blocked itself - did you try to block inside an event loop callback? Caught", 0)));
1977 PUTBACK;
1978 call_pv ("Carp::confess", G_VOID | G_DISCARD);
1979
1980 FREETMPS;
1981 LEAVE;
1982 }
1983 }
1894 1984
1895 ++coro_nready; /* hack so that api_ready doesn't invoke ready hook */ 1985 ++coro_nready; /* hack so that api_ready doesn't invoke ready hook */
1896 api_ready (aTHX_ SvRV (sv_idle)); 1986 api_ready (aTHX_ SvRV (sv_idle));
1897 --coro_nready; 1987 --coro_nready;
1898 } 1988 }
… …
2096 AV *od = coro->on_destroy; 2186 AV *od = coro->on_destroy;
2097 2187
2098 if (!od) 2188 if (!od)
2099 return; 2189 return;
2100 2190
2191 coro->on_destroy = 0;
2192 sv_2mortal ((SV *)od);
2193
2101 while (AvFILLp (od) >= 0) 2194 while (AvFILLp (od) >= 0)
2102 { 2195 {
2103 SV *cb = sv_2mortal (av_pop (od)); 2196 SV *cb = sv_2mortal (av_pop (od));
2104 2197
2105 /* coro hv's (and only hv's at the moment) are supported as well */ 2198 /* coro hv's (and only hv's at the moment) are supported as well */
… …
2199 slf_init_terminate_cancel_common (aTHX_ frame, coro_hv); 2292 slf_init_terminate_cancel_common (aTHX_ frame, coro_hv);
2200 } 2293 }
2201 else 2294 else
2202 { 2295 {
2203 struct coro *self = SvSTATE_current; 2296 struct coro *self = SvSTATE_current;
2297
2298 if (!self)
2299 croak ("Coro::cancel called outside of thread content,");
2204 2300
2205 /* otherwise we cancel directly, purely for speed reasons 2301 /* otherwise we cancel directly, purely for speed reasons
2206 * unfortunately, this requires some magic trickery, as 2302 * unfortunately, this requires some magic trickery, as
2207 * somebody else could cancel us, so we have to fight the cancellation. 2303 * somebody else could cancel us, so we have to fight the cancellation.
2208 * this is ugly, and hopefully fully worth the extra speed. 2304 * this is ugly, and hopefully fully worth the extra speed.
… …
2550 2646
2551/* "undo"/cancel a running slf call - used when cancelling a coro, mainly */ 2647/* "undo"/cancel a running slf call - used when cancelling a coro, mainly */
2552static void 2648static void
2553slf_destroy (pTHX_ struct coro *coro) 2649slf_destroy (pTHX_ struct coro *coro)
2554{ 2650{
2555 /* this callback is reserved for slf functions needing to do cleanup */ 2651 struct CoroSLF frame = coro->slf_frame;
2556 if (coro->slf_frame.destroy && coro->slf_frame.prepare && !PL_dirty)
2557 coro->slf_frame.destroy (aTHX_ &coro->slf_frame);
2558 2652
2559 /* 2653 /*
2560 * The on_destroy above most likely is from an SLF call. 2654 * The on_destroy below most likely is from an SLF call.
2561 * Since by definition the SLF call will not finish when we destroy 2655 * Since by definition the SLF call will not finish when we destroy
2562 * the coro, we will have to force-finish it here, otherwise 2656 * the coro, we will have to force-finish it here, otherwise
2563 * cleanup functions cannot call SLF functions. 2657 * cleanup functions cannot call SLF functions.
2564 */ 2658 */
2565 coro->slf_frame.prepare = 0; 2659 coro->slf_frame.prepare = 0;
2660
2661 /* this callback is reserved for slf functions needing to do cleanup */
2662 if (frame.destroy && frame.prepare && !PL_dirty)
2663 frame.destroy (aTHX_ &frame);
2566} 2664}
2567 2665
2568/* 2666/*
2569 * these not obviously related functions are all rolled into one 2667 * these not obviously related functions are all rolled into one
2570 * function to increase chances that they all will call transfer with the same 2668 * function to increase chances that they all will call transfer with the same
… …
2753static void 2851static void
2754coro_pop_on_leave (pTHX_ void *coro) 2852coro_pop_on_leave (pTHX_ void *coro)
2755{ 2853{
2756 SV *cb = coro_avp_pop_and_free (aTHX_ &((struct coro *)coro)->on_leave); 2854 SV *cb = coro_avp_pop_and_free (aTHX_ &((struct coro *)coro)->on_leave);
2757 on_enterleave_call (aTHX_ sv_2mortal (cb)); 2855 on_enterleave_call (aTHX_ sv_2mortal (cb));
2856}
2857
2858static void
2859enterleave_hook_xs (pTHX_ struct coro *coro, AV **avp, coro_enterleave_hook hook, void *arg)
2860{
2861 if (!hook)
2862 return;
2863
2864 if (!*avp)
2865 {
2866 *avp = newAV ();
2867 AvREAL_off (*avp);
2868 }
2869
2870 av_push (*avp, (SV *)hook);
2871 av_push (*avp, (SV *)arg);
2872}
2873
2874static void
2875enterleave_unhook_xs (pTHX_ struct coro *coro, AV **avp, coro_enterleave_hook hook, int execute)
2876{
2877 AV *av = *avp;
2878 int i;
2879
2880 if (!av)
2881 return;
2882
2883 for (i = AvFILLp (av) - 1; i >= 0; i -= 2)
2884 if (AvARRAY (av)[i] == (SV *)hook)
2885 {
2886 if (execute)
2887 hook (aTHX_ (void *)AvARRAY (av)[i + 1]);
2888
2889 memmove (AvARRAY (av) + i, AvARRAY (av) + i + 2, AvFILLp (av) - i - 1);
2890 av_pop (av);
2891 av_pop (av);
2892 break;
2893 }
2894
2895 if (AvFILLp (av) >= 0)
2896 {
2897 *avp = 0;
2898 SvREFCNT_dec_NN (av);
2899 }
2900}
2901
2902static void
2903api_enterleave_hook (pTHX_ SV *coro_sv, coro_enterleave_hook enter, void *enter_arg, coro_enterleave_hook leave, void *leave_arg)
2904{
2905 struct coro *coro = SvSTATE (coro_sv);
2906
2907 if (SvSTATE_current == coro)
2908 if (enter)
2909 enter (aTHX_ enter_arg);
2910
2911 enterleave_hook_xs (aTHX_ coro, &coro->on_enter_xs, enter, enter_arg);
2912 enterleave_hook_xs (aTHX_ coro, &coro->on_leave_xs, leave, leave_arg);
2913}
2914
2915static void
2916api_enterleave_unhook (pTHX_ SV *coro_sv, coro_enterleave_hook enter, coro_enterleave_hook leave)
2917{
2918 struct coro *coro = SvSTATE (coro_sv);
2919
2920 enterleave_unhook_xs (aTHX_ coro, &coro->on_enter_xs, enter, 0);
2921 enterleave_unhook_xs (aTHX_ coro, &coro->on_leave_xs, leave, SvSTATE_current == coro);
2922}
2923
2924static void
2925savedestructor_unhook_enter (pTHX_ coro_enterleave_hook enter)
2926{
2927 struct coro *coro = SvSTATE_current;
2928
2929 enterleave_unhook_xs (aTHX_ coro, &coro->on_enter_xs, enter, 0);
2930}
2931
2932static void
2933savedestructor_unhook_leave (pTHX_ coro_enterleave_hook leave)
2934{
2935 struct coro *coro = SvSTATE_current;
2936
2937 enterleave_unhook_xs (aTHX_ coro, &coro->on_leave_xs, leave, 1);
2938}
2939
2940static void
2941api_enterleave_scope_hook (pTHX_ coro_enterleave_hook enter, void *enter_arg, coro_enterleave_hook leave, void *leave_arg)
2942{
2943 api_enterleave_hook (aTHX_ coro_current, enter, enter_arg, leave, leave_arg);
2944
2945 /* this ought to be much cheaper than malloc + a single destructor call */
2946 if (enter) SAVEDESTRUCTOR_X (savedestructor_unhook_enter, enter);
2947 if (leave) SAVEDESTRUCTOR_X (savedestructor_unhook_leave, leave);
2758} 2948}
2759 2949
2760/*****************************************************************************/ 2950/*****************************************************************************/
2761/* PerlIO::cede */ 2951/* PerlIO::cede */
2762 2952
… …
2892 XPUSHs (sv_2mortal (newRV_inc ((SV *)av))); 3082 XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
2893 PUTBACK; 3083 PUTBACK;
2894 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR); 3084 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
2895 } 3085 }
2896 3086
2897 SvREFCNT_dec (cb); 3087 SvREFCNT_dec_NN (cb);
2898 } 3088 }
2899} 3089}
2900 3090
2901static void 3091static void
2902coro_semaphore_destroy (pTHX_ struct CoroSLF *frame) 3092coro_semaphore_destroy (pTHX_ struct CoroSLF *frame)
… …
2910{ 3100{
2911 AV *av = (AV *)frame->data; 3101 AV *av = (AV *)frame->data;
2912 SV *count_sv = AvARRAY (av)[0]; 3102 SV *count_sv = AvARRAY (av)[0];
2913 SV *coro_hv = SvRV (coro_current); 3103 SV *coro_hv = SvRV (coro_current);
2914 3104
3105 frame->destroy = 0;
3106
2915 /* if we are about to throw, don't actually acquire the lock, just throw */ 3107 /* if we are about to throw, don't actually acquire the lock, just throw */
2916 if (CORO_THROW) 3108 if (ecb_expect_false (CORO_THROW))
3109 {
3110 /* we still might be responsible for the semaphore, so wake up others */
3111 coro_semaphore_adjust (aTHX_ av, 0);
3112
2917 return 0; 3113 return 0;
3114 }
2918 else if (SvIVX (count_sv) > 0) 3115 else if (SvIVX (count_sv) > 0)
2919 { 3116 {
2920 frame->destroy = 0;
2921
2922 if (acquire) 3117 if (acquire)
2923 SvIVX (count_sv) = SvIVX (count_sv) - 1; 3118 SvIVX (count_sv) = SvIVX (count_sv) - 1;
2924 else 3119 else
2925 coro_semaphore_adjust (aTHX_ av, 0); 3120 coro_semaphore_adjust (aTHX_ av, 0);
2926 3121
… …
3037 { 3232 {
3038 api_ready (aTHX_ cb); 3233 api_ready (aTHX_ cb);
3039 sv_setiv (cb, 0); /* signal waiter */ 3234 sv_setiv (cb, 0); /* signal waiter */
3040 } 3235 }
3041 3236
3042 SvREFCNT_dec (cb); 3237 SvREFCNT_dec_NN (cb);
3043 3238
3044 --count; 3239 --count;
3045 } 3240 }
3046} 3241}
3047 3242
… …
3132 } 3327 }
3133 3328
3134 av_push (state, data_sv); 3329 av_push (state, data_sv);
3135 3330
3136 api_ready (aTHX_ coro); 3331 api_ready (aTHX_ coro);
3137 SvREFCNT_dec (coro); 3332 SvREFCNT_dec_NN (coro);
3138 SvREFCNT_dec ((AV *)state); 3333 SvREFCNT_dec_NN ((AV *)state);
3139} 3334}
3140 3335
3141static int 3336static int
3142slf_check_aio_req (pTHX_ struct CoroSLF *frame) 3337slf_check_aio_req (pTHX_ struct CoroSLF *frame)
3143{ 3338{
… …
3148 /* it quickly returns */ 3343 /* it quickly returns */
3149 if (CORO_THROW) 3344 if (CORO_THROW)
3150 return 0; 3345 return 0;
3151 3346
3152 /* one element that is an RV? repeat! */ 3347 /* one element that is an RV? repeat! */
3153 if (AvFILLp (state) == 0 && SvROK (AvARRAY (state)[0])) 3348 if (AvFILLp (state) == 0 && SvTYPE (AvARRAY (state)[0]) != SVt_PV)
3154 return 1; 3349 return 1;
3155 3350
3156 /* restore status */ 3351 /* restore status */
3157 { 3352 {
3158 SV *data_sv = av_pop (state); 3353 SV *data_sv = av_pop (state);
… …
3161 errno = data->errorno; 3356 errno = data->errorno;
3162 PL_laststype = data->laststype; 3357 PL_laststype = data->laststype;
3163 PL_laststatval = data->laststatval; 3358 PL_laststatval = data->laststatval;
3164 PL_statcache = data->statcache; 3359 PL_statcache = data->statcache;
3165 3360
3166 SvREFCNT_dec (data_sv); 3361 SvREFCNT_dec_NN (data_sv);
3167 } 3362 }
3168 3363
3169 /* push result values */ 3364 /* push result values */
3170 { 3365 {
3171 dSP; 3366 dSP;
… …
3386 3581
3387PROTOTYPES: DISABLE 3582PROTOTYPES: DISABLE
3388 3583
3389BOOT: 3584BOOT:
3390{ 3585{
3586#define VARx(name,expr,type) if (sizeof (type) < sizeof (expr)) croak ("FATAL: Coro thread context slot '" # name "' too small for this version of perl.");
3587#include "state.h"
3391#ifdef USE_ITHREADS 3588#ifdef USE_ITHREADS
3392# if CORO_PTHREAD 3589# if CORO_PTHREAD
3393 coro_thx = PERL_GET_CONTEXT; 3590 coro_thx = PERL_GET_CONTEXT;
3394# endif 3591# endif
3395#endif 3592#endif
… …
3470void 3667void
3471transfer (...) 3668transfer (...)
3472 PROTOTYPE: $$ 3669 PROTOTYPE: $$
3473 CODE: 3670 CODE:
3474 CORO_EXECUTE_SLF_XS (slf_init_transfer); 3671 CORO_EXECUTE_SLF_XS (slf_init_transfer);
3475
3476void
3477_exit (int code)
3478 PROTOTYPE: $
3479 CODE:
3480 _exit (code);
3481 3672
3482SV * 3673SV *
3483clone (Coro::State coro) 3674clone (Coro::State coro)
3484 CODE: 3675 CODE:
3485{ 3676{
… …
3752 3943
3753MODULE = Coro::State PACKAGE = Coro 3944MODULE = Coro::State PACKAGE = Coro
3754 3945
3755BOOT: 3946BOOT:
3756{ 3947{
3948 if (SVt_LAST > 32)
3949 croak ("Coro internal error: SVt_LAST > 32, swap_sv might need adjustment");
3950
3757 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE); 3951 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3758 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE); 3952 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3759 cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD); 3953 cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3760 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current); 3954 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);
3761 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE); 3955 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
… …
3787 coroapi.ready = api_ready; 3981 coroapi.ready = api_ready;
3788 coroapi.is_ready = api_is_ready; 3982 coroapi.is_ready = api_is_ready;
3789 coroapi.nready = coro_nready; 3983 coroapi.nready = coro_nready;
3790 coroapi.current = coro_current; 3984 coroapi.current = coro_current;
3791 3985
3986 coroapi.enterleave_hook = api_enterleave_hook;
3987 coroapi.enterleave_unhook = api_enterleave_unhook;
3988 coroapi.enterleave_scope_hook = api_enterleave_scope_hook;
3989
3792 /*GCoroAPI = &coroapi;*/ 3990 /*GCoroAPI = &coroapi;*/
3793 sv_setiv (sv, (IV)&coroapi); 3991 sv_setiv (sv, (IV)&coroapi);
3794 SvREADONLY_on (sv); 3992 SvREADONLY_on (sv);
3795 } 3993 }
3796} 3994}
… …
3861 4059
3862void 4060void
3863_set_current (SV *current) 4061_set_current (SV *current)
3864 PROTOTYPE: $ 4062 PROTOTYPE: $
3865 CODE: 4063 CODE:
3866 SvREFCNT_dec (SvRV (coro_current)); 4064 SvREFCNT_dec_NN (SvRV (coro_current));
3867 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current))); 4065 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
3868 4066
3869void 4067void
3870_set_readyhook (SV *hook) 4068_set_readyhook (SV *hook)
3871 PROTOTYPE: $ 4069 PROTOTYPE: $
… …
3955 4153
3956 if ((SV *)hv == &PL_sv_undef) 4154 if ((SV *)hv == &PL_sv_undef)
3957 { 4155 {
3958 SV *sv = coro_new (aTHX_ coro_stash, (SV **)&cv_pool_handler, 1, 1); 4156 SV *sv = coro_new (aTHX_ coro_stash, (SV **)&cv_pool_handler, 1, 1);
3959 hv = (HV *)SvREFCNT_inc_NN (SvRV (sv)); 4157 hv = (HV *)SvREFCNT_inc_NN (SvRV (sv));
3960 SvREFCNT_dec (sv); 4158 SvREFCNT_dec_NN (sv);
3961 } 4159 }
3962 4160
3963 { 4161 {
3964 struct coro *coro = SvSTATE_hv (hv); 4162 struct coro *coro = SvSTATE_hv (hv);
3965 4163
… …
3972 api_ready (aTHX_ (SV *)hv); 4170 api_ready (aTHX_ (SV *)hv);
3973 4171
3974 if (GIMME_V != G_VOID) 4172 if (GIMME_V != G_VOID)
3975 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv))); 4173 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
3976 else 4174 else
3977 SvREFCNT_dec (hv); 4175 SvREFCNT_dec_NN (hv);
3978} 4176}
3979 4177
3980SV * 4178SV *
3981rouse_cb () 4179rouse_cb ()
3982 PROTOTYPE: 4180 PROTOTYPE:
… …
4237 { 4435 {
4238 PL_ppaddr [OP_SSELECT] = coro_old_pp_sselect; 4436 PL_ppaddr [OP_SSELECT] = coro_old_pp_sselect;
4239 coro_old_pp_sselect = 0; 4437 coro_old_pp_sselect = 0;
4240 } 4438 }
4241 4439
4440MODULE = Coro::State PACKAGE = Coro::Util
4441
4442void
4443_exit (int code)
4444 CODE:
4445 _exit (code);
4446
4447NV
4448time ()
4449 CODE:
4450 RETVAL = nvtime (aTHX);
4451 OUTPUT:
4452 RETVAL
4453
4454NV
4455gettimeofday ()
4456 PPCODE:
4457{
4458 UV tv [2];
4459 u2time (aTHX_ tv);
4460 EXTEND (SP, 2);
4461 PUSHs (sv_2mortal (newSVuv (tv [0])));
4462 PUSHs (sv_2mortal (newSVuv (tv [1])));
4463}
4464

Diff Legend

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