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.236 by root, Sat May 10 17:43:41 2008 UTC vs.
Revision 1.251 by root, Thu Oct 30 09:44:31 2008 UTC

… …
4#define PERL_EXT 4#define PERL_EXT
5 5
6#include "EXTERN.h" 6#include "EXTERN.h"
7#include "perl.h" 7#include "perl.h"
8#include "XSUB.h" 8#include "XSUB.h"
9#include "perliol.h"
9 10
10#include "patchlevel.h" 11#include "patchlevel.h"
11 12
12#include <stdio.h> 13#include <stdio.h>
13#include <errno.h> 14#include <errno.h>
… …
80# ifndef IS_PADCONST 81# ifndef IS_PADCONST
81# define IS_PADCONST(v) 0 82# define IS_PADCONST(v) 0
82# endif 83# endif
83#endif 84#endif
84 85
86/* 5.11 */
87#ifndef CxHASARGS
88# define CxHASARGS(cx) (cx)->blk_sub.hasargs
89#endif
90
91/* 5.10.0 */
92#ifndef SvREFCNT_inc_NN
93# define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
94#endif
95
85/* 5.8.8 */ 96/* 5.8.8 */
86#ifndef GV_NOTQUAL 97#ifndef GV_NOTQUAL
87# define GV_NOTQUAL 0 98# define GV_NOTQUAL 0
88#endif 99#endif
89#ifndef newSV 100#ifndef newSV
90# define newSV(l) NEWSV(0,l) 101# define newSV(l) NEWSV(0,l)
91#endif
92
93/* 5.11 */
94#ifndef CxHASARGS
95# define CxHASARGS(cx) (cx)->blk_sub.hasargs
96#endif 102#endif
97 103
98/* 5.8.7 */ 104/* 5.8.7 */
99#ifndef SvRV_set 105#ifndef SvRV_set
100# define SvRV_set(s,v) SvRV(s) = (v) 106# define SvRV_set(s,v) SvRV(s) = (v)
… …
147#endif 153#endif
148 154
149/* helper storage struct for Coro::AIO */ 155/* helper storage struct for Coro::AIO */
150struct io_state 156struct io_state
151{ 157{
158 AV *res;
152 int errorno; 159 int errorno;
153 I32 laststype; 160 I32 laststype;
154 int laststatval; 161 int laststatval;
155 Stat_t statcache; 162 Stat_t statcache;
156}; 163};
164
165static double (*nvtime)(); /* so why doesn't it take void? */
157 166
158static size_t coro_stacksize = CORO_STACKSIZE; 167static size_t coro_stacksize = CORO_STACKSIZE;
159static struct CoroAPI coroapi; 168static struct CoroAPI coroapi;
160static AV *main_mainstack; /* used to differentiate between $main and others */ 169static AV *main_mainstack; /* used to differentiate between $main and others */
161static JMPENV *main_top_env; 170static JMPENV *main_top_env;
… …
321 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1); 330 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
322#endif 331#endif
323 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)]; 332 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
324 --AvFILLp (padlist); 333 --AvFILLp (padlist);
325 334
326 av_store (newpadlist, 0, SvREFCNT_inc (*av_fetch (padlist, 0, FALSE))); 335 av_store (newpadlist, 0, SvREFCNT_inc_NN (*av_fetch (padlist, 0, FALSE)));
327 av_store (newpadlist, 1, (SV *)newpad); 336 av_store (newpadlist, 1, (SV *)newpad);
328 337
329 return newpadlist; 338 return newpadlist;
330} 339}
331 340
… …
361 370
362 /* casting is fun. */ 371 /* casting is fun. */
363 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av))) 372 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
364 free_padlist (aTHX_ padlist); 373 free_padlist (aTHX_ padlist);
365 374
375 SvREFCNT_dec (av); /* sv_magicext increased the refcount */
376
366 return 0; 377 return 0;
367} 378}
368 379
369#define CORO_MAGIC_type_cv PERL_MAGIC_ext 380#define CORO_MAGIC_type_cv PERL_MAGIC_ext
370#define CORO_MAGIC_type_state PERL_MAGIC_ext 381#define CORO_MAGIC_type_state PERL_MAGIC_ext
… …
420 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0)) 431 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
421 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--]; 432 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
422 else 433 else
423 { 434 {
424#if CORO_PREFER_PERL_FUNCTIONS 435#if CORO_PREFER_PERL_FUNCTIONS
425 /* this is probably cleaner, but also slower? */ 436 /* this is probably cleaner? but also slower! */
437 /* in practise, it seems to be less stable */
426 CV *cp = Perl_cv_clone (cv); 438 CV *cp = Perl_cv_clone (cv);
427 CvPADLIST (cv) = CvPADLIST (cp); 439 CvPADLIST (cv) = CvPADLIST (cp);
428 CvPADLIST (cp) = 0; 440 CvPADLIST (cp) = 0;
429 SvREFCNT_dec (cp); 441 SvREFCNT_dec (cp);
430#else 442#else
… …
663 #undef VAR 675 #undef VAR
664 } 676 }
665 else 677 else
666 slot = coro->slot; 678 slot = coro->slot;
667 679
680 if (slot)
681 {
668 rss += sizeof (slot->curstackinfo); 682 rss += sizeof (slot->curstackinfo);
669 rss += (slot->curstackinfo->si_cxmax + 1) * sizeof (PERL_CONTEXT); 683 rss += (slot->curstackinfo->si_cxmax + 1) * sizeof (PERL_CONTEXT);
670 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (slot->curstack)) * sizeof (SV *); 684 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (slot->curstack)) * sizeof (SV *);
671 rss += slot->tmps_max * sizeof (SV *); 685 rss += slot->tmps_max * sizeof (SV *);
672 rss += (slot->markstack_max - slot->markstack_ptr) * sizeof (I32); 686 rss += (slot->markstack_max - slot->markstack_ptr) * sizeof (I32);
673 rss += slot->scopestack_max * sizeof (I32); 687 rss += slot->scopestack_max * sizeof (I32);
674 rss += slot->savestack_max * sizeof (ANY); 688 rss += slot->savestack_max * sizeof (ANY);
675 689
676#if !PERL_VERSION_ATLEAST (5,10,0) 690#if !PERL_VERSION_ATLEAST (5,10,0)
677 rss += slot->retstack_max * sizeof (OP *); 691 rss += slot->retstack_max * sizeof (OP *);
678#endif 692#endif
693 }
679 } 694 }
680 695
681 return rss; 696 return rss;
682} 697}
683 698
684/** coroutine stack handling ************************************************/ 699/** coroutine stack handling ************************************************/
685 700
686static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg); 701static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg);
687static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg); 702static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg);
703static int (*orig_sigelem_clr) (pTHX_ SV *sv, MAGIC *mg);
704
705/* apparently < 5.8.8 */
706#ifndef MgPV_nolen_const
707#define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \
708 SvPV_nolen((SV*)((mg)->mg_ptr)) : \
709 (const char*)(mg)->mg_ptr)
710#endif
688 711
689/* 712/*
690 * This overrides the default magic get method of %SIG elements. 713 * This overrides the default magic get method of %SIG elements.
691 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook 714 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook
692 * and instead of tryign to save and restore the hash elements, we just provide 715 * and instead of tryign to save and restore the hash elements, we just provide
… …
700{ 723{
701 const char *s = MgPV_nolen_const (mg); 724 const char *s = MgPV_nolen_const (mg);
702 725
703 if (*s == '_') 726 if (*s == '_')
704 { 727 {
705 if (strEQ (s, "__DIE__" ) && PL_diehook ) return sv_setsv (sv, PL_diehook ), 0; 728 SV **svp = 0;
706 if (strEQ (s, "__WARN__") && PL_warnhook) return sv_setsv (sv, PL_warnhook), 0; 729
730 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
731 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
732
733 if (svp)
734 {
735 sv_setsv (sv, *svp ? *svp : &PL_sv_undef);
736 return 0;
737 }
707 } 738 }
708 739
709 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0; 740 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
741}
742
743static int
744coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
745{
746 const char *s = MgPV_nolen_const (mg);
747
748 if (*s == '_')
749 {
750 SV **svp = 0;
751
752 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
753 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
754
755 if (svp)
756 {
757 SV *old = *svp;
758 *svp = 0;
759 SvREFCNT_dec (old);
760 return 0;
761 }
762 }
763
764 return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
710} 765}
711 766
712static int 767static int
713coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg) 768coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
714{ 769{
… …
761 GvSV (PL_defgv) = newSV (0); 816 GvSV (PL_defgv) = newSV (0);
762 GvAV (PL_defgv) = coro->args; coro->args = 0; 817 GvAV (PL_defgv) = coro->args; coro->args = 0;
763 GvSV (PL_errgv) = newSV (0); 818 GvSV (PL_errgv) = newSV (0);
764 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0); 819 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
765 PL_rs = newSVsv (GvSV (irsgv)); 820 PL_rs = newSVsv (GvSV (irsgv));
766 PL_defoutgv = (GV *)SvREFCNT_inc (stdoutgv); 821 PL_defoutgv = (GV *)SvREFCNT_inc_NN (stdoutgv);
767 822
768 { 823 {
769 dSP; 824 dSP;
770 LOGOP myop; 825 LOGOP myop;
771 826
… …
867 : cx->blk_gimme == G_SCALAR ? bot + 1 922 : cx->blk_gimme == G_SCALAR ? bot + 1
868 : bot; 923 : bot;
869 924
870 av_extend (av, top - bot); 925 av_extend (av, top - bot);
871 while (bot < top) 926 while (bot < top)
872 av_push (av, SvREFCNT_inc (*bot++)); 927 av_push (av, SvREFCNT_inc_NN (*bot++));
873 928
874 PL_runops = RUNOPS_DEFAULT; 929 PL_runops = RUNOPS_DEFAULT;
875 ENTER; 930 ENTER;
876 SAVETMPS; 931 SAVETMPS;
877 EXTEND (SP, 3); 932 EXTEND (SP, 3);
… …
1383static int 1438static int
1384api_ready (SV *coro_sv) 1439api_ready (SV *coro_sv)
1385{ 1440{
1386 dTHX; 1441 dTHX;
1387 struct coro *coro; 1442 struct coro *coro;
1388 SV *hook; 1443 SV *sv_hook;
1444 void (*xs_hook)(void);
1389 1445
1390 if (SvROK (coro_sv)) 1446 if (SvROK (coro_sv))
1391 coro_sv = SvRV (coro_sv); 1447 coro_sv = SvRV (coro_sv);
1392 1448
1393 coro = SvSTATE (coro_sv); 1449 coro = SvSTATE (coro_sv);
… …
1397 1453
1398 coro->flags |= CF_READY; 1454 coro->flags |= CF_READY;
1399 1455
1400 LOCK; 1456 LOCK;
1401 1457
1402 hook = coro_nready ? 0 : coro_readyhook; 1458 sv_hook = coro_nready ? 0 : coro_readyhook;
1459 xs_hook = coro_nready ? 0 : coroapi.readyhook;
1403 1460
1404 coro_enq (aTHX_ SvREFCNT_inc (coro_sv)); 1461 coro_enq (aTHX_ SvREFCNT_inc_NN (coro_sv));
1405 ++coro_nready; 1462 ++coro_nready;
1406 1463
1407 UNLOCK; 1464 UNLOCK;
1408 1465
1409 if (hook) 1466 if (sv_hook)
1410 { 1467 {
1411 dSP; 1468 dSP;
1412 1469
1413 ENTER; 1470 ENTER;
1414 SAVETMPS; 1471 SAVETMPS;
1415 1472
1416 PUSHMARK (SP); 1473 PUSHMARK (SP);
1417 PUTBACK; 1474 PUTBACK;
1418 call_sv (hook, G_DISCARD); 1475 call_sv (sv_hook, G_DISCARD);
1419 SPAGAIN; 1476 SPAGAIN;
1420 1477
1421 FREETMPS; 1478 FREETMPS;
1422 LEAVE; 1479 LEAVE;
1423 } 1480 }
1481
1482 if (xs_hook)
1483 xs_hook ();
1424 1484
1425 return 1; 1485 return 1;
1426} 1486}
1427 1487
1428static int 1488static int
… …
1578 else 1638 else
1579 coro->slot->runops = RUNOPS_DEFAULT; 1639 coro->slot->runops = RUNOPS_DEFAULT;
1580 } 1640 }
1581} 1641}
1582 1642
1643static int
1644coro_gensub_free (pTHX_ SV *sv, MAGIC *mg)
1645{
1646 AV *padlist;
1647 AV *av = (AV *)mg->mg_obj;
1648
1649 abort ();
1650
1651 return 0;
1652}
1653
1654static MGVTBL coro_gensub_vtbl = {
1655 0, 0, 0, 0,
1656 coro_gensub_free
1657};
1658
1659/*****************************************************************************/
1660/* PerlIO::cede */
1661
1662typedef struct
1663{
1664 PerlIOBuf base;
1665 NV next, every;
1666} PerlIOCede;
1667
1668static IV
1669PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1670{
1671 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1672
1673 self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
1674 self->next = nvtime () + self->every;
1675
1676 return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
1677}
1678
1679static SV *
1680PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
1681{
1682 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1683
1684 return newSVnv (self->every);
1685}
1686
1687static IV
1688PerlIOCede_flush (pTHX_ PerlIO *f)
1689{
1690 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1691 double now = nvtime ();
1692
1693 if (now >= self->next)
1694 {
1695 api_cede ();
1696 self->next = now + self->every;
1697 }
1698
1699 return PerlIOBuf_flush (aTHX_ f);
1700}
1701
1702static PerlIO_funcs PerlIO_cede =
1703{
1704 sizeof(PerlIO_funcs),
1705 "cede",
1706 sizeof(PerlIOCede),
1707 PERLIO_K_DESTRUCT | PERLIO_K_RAW,
1708 PerlIOCede_pushed,
1709 PerlIOBuf_popped,
1710 PerlIOBuf_open,
1711 PerlIOBase_binmode,
1712 PerlIOCede_getarg,
1713 PerlIOBase_fileno,
1714 PerlIOBuf_dup,
1715 PerlIOBuf_read,
1716 PerlIOBuf_unread,
1717 PerlIOBuf_write,
1718 PerlIOBuf_seek,
1719 PerlIOBuf_tell,
1720 PerlIOBuf_close,
1721 PerlIOCede_flush,
1722 PerlIOBuf_fill,
1723 PerlIOBase_eof,
1724 PerlIOBase_error,
1725 PerlIOBase_clearerr,
1726 PerlIOBase_setlinebuf,
1727 PerlIOBuf_get_base,
1728 PerlIOBuf_bufsiz,
1729 PerlIOBuf_get_ptr,
1730 PerlIOBuf_get_cnt,
1731 PerlIOBuf_set_ptrcnt,
1732};
1733
1734
1583MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_ 1735MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
1584 1736
1585PROTOTYPES: DISABLE 1737PROTOTYPES: DISABLE
1586 1738
1587BOOT: 1739BOOT:
… …
1592 BOOT_PAGESIZE; 1744 BOOT_PAGESIZE;
1593 1745
1594 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV); 1746 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
1595 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO); 1747 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
1596 1748
1597 orig_sigelem_get = PL_vtbl_sigelem.svt_get; 1749 orig_sigelem_get = PL_vtbl_sigelem.svt_get; PL_vtbl_sigelem.svt_get = coro_sigelem_get;
1598 PL_vtbl_sigelem.svt_get = coro_sigelem_get; 1750 orig_sigelem_set = PL_vtbl_sigelem.svt_set; PL_vtbl_sigelem.svt_set = coro_sigelem_set;
1599 orig_sigelem_set = PL_vtbl_sigelem.svt_set; 1751 orig_sigelem_clr = PL_vtbl_sigelem.svt_clear; PL_vtbl_sigelem.svt_clear = coro_sigelem_clr;
1600 PL_vtbl_sigelem.svt_set = coro_sigelem_set;
1601 1752
1602 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE); 1753 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE);
1603 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV)); 1754 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV));
1604 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV)); 1755 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV));
1605 1756
… …
1614 main_top_env = PL_top_env; 1765 main_top_env = PL_top_env;
1615 1766
1616 while (main_top_env->je_prev) 1767 while (main_top_env->je_prev)
1617 main_top_env = main_top_env->je_prev; 1768 main_top_env = main_top_env->je_prev;
1618 1769
1619 coroapi.ver = CORO_API_VERSION; 1770 coroapi.ver = CORO_API_VERSION;
1620 coroapi.rev = CORO_API_REVISION; 1771 coroapi.rev = CORO_API_REVISION;
1621 coroapi.transfer = api_transfer; 1772 coroapi.transfer = api_transfer;
1773
1774 {
1775 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1776
1777 if (!svp) croak ("Time::HiRes is required");
1778 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
1779
1780 nvtime = INT2PTR (double (*)(), SvIV (*svp));
1781 }
1622 1782
1623 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL)); 1783 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
1624} 1784}
1625 1785
1626SV * 1786SV *
… …
1754call (Coro::State coro, SV *coderef) 1914call (Coro::State coro, SV *coderef)
1755 ALIAS: 1915 ALIAS:
1756 eval = 1 1916 eval = 1
1757 CODE: 1917 CODE:
1758{ 1918{
1759 if (coro->mainstack) 1919 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
1760 { 1920 {
1761 struct coro temp; 1921 struct coro temp;
1762 1922
1763 if (!(coro->flags & CF_RUNNING)) 1923 if (!(coro->flags & CF_RUNNING))
1764 { 1924 {
… …
1846force_cctx () 2006force_cctx ()
1847 CODE: 2007 CODE:
1848 struct coro *coro = SvSTATE (coro_current); 2008 struct coro *coro = SvSTATE (coro_current);
1849 coro->cctx->idle_sp = 0; 2009 coro->cctx->idle_sp = 0;
1850 2010
1851MODULE = Coro::State PACKAGE = Coro
1852
1853BOOT:
1854{
1855 int i;
1856
1857 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
1858 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
1859 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
1860
1861 coro_current = coro_get_sv (aTHX_ "Coro::current", FALSE);
1862 SvREADONLY_on (coro_current);
1863
1864 coro_stash = gv_stashpv ("Coro", TRUE);
1865
1866 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
1867 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
1868 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
1869 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
1870 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
1871 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
1872
1873 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
1874 coro_ready[i] = newAV ();
1875
1876 {
1877 SV *sv = perl_get_sv ("Coro::API", TRUE);
1878 perl_get_sv ("Coro::API", TRUE); /* silence 5.10 warning */
1879
1880 coroapi.schedule = api_schedule;
1881 coroapi.cede = api_cede;
1882 coroapi.cede_notself = api_cede_notself;
1883 coroapi.ready = api_ready;
1884 coroapi.is_ready = api_is_ready;
1885 coroapi.nready = &coro_nready;
1886 coroapi.current = coro_current;
1887
1888 GCoroAPI = &coroapi;
1889 sv_setiv (sv, (IV)&coroapi);
1890 SvREADONLY_on (sv);
1891 }
1892}
1893
1894void
1895_set_current (SV *current)
1896 PROTOTYPE: $
1897 CODE:
1898 SvREFCNT_dec (SvRV (coro_current));
1899 SvRV_set (coro_current, SvREFCNT_inc (SvRV (current)));
1900
1901void
1902_set_readyhook (SV *hook)
1903 PROTOTYPE: $
1904 CODE:
1905 LOCK;
1906 SvREFCNT_dec (coro_readyhook);
1907 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
1908 UNLOCK;
1909
1910int
1911prio (Coro::State coro, int newprio = 0)
1912 ALIAS:
1913 nice = 1
1914 CODE:
1915{
1916 RETVAL = coro->prio;
1917
1918 if (items > 1)
1919 {
1920 if (ix)
1921 newprio = coro->prio - newprio;
1922
1923 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
1924 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
1925
1926 coro->prio = newprio;
1927 }
1928}
1929 OUTPUT:
1930 RETVAL
1931
1932SV *
1933ready (SV *self)
1934 PROTOTYPE: $
1935 CODE:
1936 RETVAL = boolSV (api_ready (self));
1937 OUTPUT:
1938 RETVAL
1939
1940int
1941nready (...)
1942 PROTOTYPE:
1943 CODE:
1944 RETVAL = coro_nready;
1945 OUTPUT:
1946 RETVAL
1947
1948void 2011void
1949throw (Coro::State self, SV *throw = &PL_sv_undef) 2012throw (Coro::State self, SV *throw = &PL_sv_undef)
1950 PROTOTYPE: $;$ 2013 PROTOTYPE: $;$
1951 CODE: 2014 CODE:
1952 SvREFCNT_dec (self->throw); 2015 SvREFCNT_dec (self->throw);
… …
1966 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv; 2029 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
1967 2030
1968 SV *tmp = *src; *src = *dst; *dst = tmp; 2031 SV *tmp = *src; *src = *dst; *dst = tmp;
1969 } 2032 }
1970 2033
2034MODULE = Coro::State PACKAGE = Coro
2035
2036BOOT:
2037{
2038 int i;
2039
2040 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
2041 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
2042 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
2043
2044 coro_current = coro_get_sv (aTHX_ "Coro::current", FALSE);
2045 SvREADONLY_on (coro_current);
2046
2047 coro_stash = gv_stashpv ("Coro", TRUE);
2048
2049 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
2050 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
2051 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
2052 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
2053 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
2054 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
2055
2056 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
2057 coro_ready[i] = newAV ();
2058
2059 {
2060 SV *sv = perl_get_sv ("Coro::API", TRUE);
2061 perl_get_sv ("Coro::API", TRUE); /* silence 5.10 warning */
2062
2063 coroapi.schedule = api_schedule;
2064 coroapi.cede = api_cede;
2065 coroapi.cede_notself = api_cede_notself;
2066 coroapi.ready = api_ready;
2067 coroapi.is_ready = api_is_ready;
2068 coroapi.nready = &coro_nready;
2069 coroapi.current = coro_current;
2070
2071 GCoroAPI = &coroapi;
2072 sv_setiv (sv, (IV)&coroapi);
2073 SvREADONLY_on (sv);
2074 }
2075}
2076
2077void
2078_set_current (SV *current)
2079 PROTOTYPE: $
2080 CODE:
2081 SvREFCNT_dec (SvRV (coro_current));
2082 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
2083
2084void
2085_set_readyhook (SV *hook)
2086 PROTOTYPE: $
2087 CODE:
2088 LOCK;
2089 SvREFCNT_dec (coro_readyhook);
2090 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
2091 UNLOCK;
2092
2093int
2094prio (Coro::State coro, int newprio = 0)
2095 ALIAS:
2096 nice = 1
2097 CODE:
2098{
2099 RETVAL = coro->prio;
2100
2101 if (items > 1)
2102 {
2103 if (ix)
2104 newprio = coro->prio - newprio;
2105
2106 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
2107 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
2108
2109 coro->prio = newprio;
2110 }
2111}
2112 OUTPUT:
2113 RETVAL
2114
2115SV *
2116ready (SV *self)
2117 PROTOTYPE: $
2118 CODE:
2119 RETVAL = boolSV (api_ready (self));
2120 OUTPUT:
2121 RETVAL
2122
2123int
2124nready (...)
2125 PROTOTYPE:
2126 CODE:
2127 RETVAL = coro_nready;
2128 OUTPUT:
2129 RETVAL
2130
1971# for async_pool speedup 2131# for async_pool speedup
1972void 2132void
1973_pool_1 (SV *cb) 2133_pool_1 (SV *cb)
1974 CODE: 2134 CODE:
1975{ 2135{
… …
1980 AV *invoke_av; 2140 AV *invoke_av;
1981 int i, len; 2141 int i, len;
1982 2142
1983 if (!invoke) 2143 if (!invoke)
1984 { 2144 {
1985 SvREFCNT_dec (PL_diehook); PL_diehook = 0; 2145 SV *old = PL_diehook;
2146 PL_diehook = 0;
2147 SvREFCNT_dec (old);
1986 croak ("\3async_pool terminate\2\n"); 2148 croak ("\3async_pool terminate\2\n");
1987 } 2149 }
1988 2150
1989 SvREFCNT_dec (coro->saved_deffh); 2151 SvREFCNT_dec (coro->saved_deffh);
1990 coro->saved_deffh = SvREFCNT_inc ((SV *)PL_defoutgv); 2152 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
1991 2153
1992 hv_store (hv, "desc", sizeof ("desc") - 1, 2154 hv_store (hv, "desc", sizeof ("desc") - 1,
1993 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0); 2155 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
1994 2156
1995 invoke_av = (AV *)SvRV (invoke); 2157 invoke_av = (AV *)SvRV (invoke);
… …
1999 2161
2000 if (len > 0) 2162 if (len > 0)
2001 { 2163 {
2002 av_fill (defav, len - 1); 2164 av_fill (defav, len - 1);
2003 for (i = 0; i < len; ++i) 2165 for (i = 0; i < len; ++i)
2004 av_store (defav, i, SvREFCNT_inc (AvARRAY (invoke_av)[i + 1])); 2166 av_store (defav, i, SvREFCNT_inc_NN (AvARRAY (invoke_av)[i + 1]));
2005 } 2167 }
2006 2168
2007 SvREFCNT_dec (invoke); 2169 SvREFCNT_dec (invoke);
2008} 2170}
2009 2171
… …
2019 coro->saved_deffh = 0; 2181 coro->saved_deffh = 0;
2020 2182
2021 if (coro_rss (aTHX_ coro) > SvIV (sv_pool_rss) 2183 if (coro_rss (aTHX_ coro) > SvIV (sv_pool_rss)
2022 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size)) 2184 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2023 { 2185 {
2024 SvREFCNT_dec (PL_diehook); PL_diehook = 0; 2186 SV *old = PL_diehook;
2187 PL_diehook = 0;
2188 SvREFCNT_dec (old);
2025 croak ("\3async_pool terminate\2\n"); 2189 croak ("\3async_pool terminate\2\n");
2026 } 2190 }
2027 2191
2028 av_clear (GvAV (PL_defgv)); 2192 av_clear (GvAV (PL_defgv));
2029 hv_store ((HV *)SvRV (coro_current), "desc", sizeof ("desc") - 1, 2193 hv_store ((HV *)SvRV (coro_current), "desc", sizeof ("desc") - 1,
… …
2035 api_trace (coro_current, 0); 2199 api_trace (coro_current, 0);
2036 2200
2037 av_push (av_async_pool, newSVsv (coro_current)); 2201 av_push (av_async_pool, newSVsv (coro_current));
2038} 2202}
2039 2203
2204#if 0
2205
2206void
2207_generator_call (...)
2208 PROTOTYPE: @
2209 PPCODE:
2210 fprintf (stderr, "call %p\n", CvXSUBANY(cv).any_ptr);
2211 xxxx
2212 abort ();
2213
2214SV *
2215gensub (SV *sub, ...)
2216 PROTOTYPE: &;@
2217 CODE:
2218{
2219 struct coro *coro;
2220 MAGIC *mg;
2221 CV *xcv;
2222 CV *ncv = (CV *)newSV_type (SVt_PVCV);
2223 int i;
2224
2225 CvGV (ncv) = CvGV (cv);
2226 CvFILE (ncv) = CvFILE (cv);
2227
2228 Newz (0, coro, 1, struct coro);
2229 coro->args = newAV ();
2230 coro->flags = CF_NEW;
2231
2232 av_extend (coro->args, items - 1);
2233 for (i = 1; i < items; i++)
2234 av_push (coro->args, newSVsv (ST (i)));
2235
2236 CvISXSUB_on (ncv);
2237 CvXSUBANY (ncv).any_ptr = (void *)coro;
2238
2239 xcv = GvCV (gv_fetchpv ("Coro::_generator_call", 0, SVt_PVCV));
2240
2241 CvXSUB (ncv) = CvXSUB (xcv);
2242 CvANON_on (ncv);
2243
2244 mg = sv_magicext ((SV *)ncv, 0, CORO_MAGIC_type_state, &coro_gensub_vtbl, (char *)coro, 0);
2245 RETVAL = newRV_noinc ((SV *)ncv);
2246}
2247 OUTPUT:
2248 RETVAL
2249
2250#endif
2251
2040 2252
2041MODULE = Coro::State PACKAGE = Coro::AIO 2253MODULE = Coro::State PACKAGE = Coro::AIO
2042 2254
2043SV * 2255void
2044_get_state () 2256_get_state (SV *self)
2045 CODE: 2257 PPCODE:
2046{ 2258{
2047 struct io_state *data; 2259 AV *defav = GvAV (PL_defgv);
2048 2260 AV *av = newAV ();
2261 int i;
2049 RETVAL = newSV (sizeof (struct io_state)); 2262 SV *data_sv = newSV (sizeof (struct io_state));
2050 data = (struct io_state *)SvPVX (RETVAL); 2263 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2051 SvCUR_set (RETVAL, sizeof (struct io_state)); 2264 SvCUR_set (data_sv, sizeof (struct io_state));
2052 SvPOK_only (RETVAL); 2265 SvPOK_only (data_sv);
2053 2266
2054 data->errorno = errno; 2267 data->errorno = errno;
2055 data->laststype = PL_laststype; 2268 data->laststype = PL_laststype;
2056 data->laststatval = PL_laststatval; 2269 data->laststatval = PL_laststatval;
2057 data->statcache = PL_statcache; 2270 data->statcache = PL_statcache;
2271
2272 av_extend (av, AvFILLp (defav) + 1 + 1);
2273
2274 for (i = 0; i <= AvFILLp (defav); ++i)
2275 av_push (av, SvREFCNT_inc_NN (AvARRAY (defav)[i]));
2276
2277 av_push (av, data_sv);
2278
2279 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
2280
2281 api_ready (self);
2058} 2282}
2059 OUTPUT:
2060 RETVAL
2061 2283
2062void 2284void
2063_set_state (char *data_) 2285_set_state (SV *state)
2064 PROTOTYPE: $ 2286 PROTOTYPE: $
2065 CODE: 2287 PPCODE:
2066{ 2288{
2067 struct io_state *data = (void *)data_; 2289 AV *av = (AV *)SvRV (state);
2290 struct io_state *data = (struct io_state *)SvPVX (AvARRAY (av)[AvFILLp (av)]);
2291 int i;
2068 2292
2069 errno = data->errorno; 2293 errno = data->errorno;
2070 PL_laststype = data->laststype; 2294 PL_laststype = data->laststype;
2071 PL_laststatval = data->laststatval; 2295 PL_laststatval = data->laststatval;
2072 PL_statcache = data->statcache; 2296 PL_statcache = data->statcache;
2297
2298 EXTEND (SP, AvFILLp (av));
2299 for (i = 0; i < AvFILLp (av); ++i)
2300 PUSHs (sv_2mortal (SvREFCNT_inc_NN (AvARRAY (av)[i])));
2073} 2301}
2074 2302
2075 2303
2076MODULE = Coro::State PACKAGE = Coro::AnyEvent 2304MODULE = Coro::State PACKAGE = Coro::AnyEvent
2077 2305
2078BOOT: 2306BOOT:
2079 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE); 2307 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE);
2080 2308
2081SV * 2309SV *
2082_schedule () 2310_schedule (...)
2083 PROTOTYPE: @ 2311 PROTOTYPE: @
2084 CODE: 2312 CODE:
2085{ 2313{
2086 static int incede; 2314 static int incede;
2087 2315
… …
2101 } 2329 }
2102 2330
2103 --incede; 2331 --incede;
2104} 2332}
2105 2333
2334
2335MODULE = Coro::State PACKAGE = PerlIO::cede
2336
2337BOOT:
2338 PerlIO_define_layer (aTHX_ &PerlIO_cede);

Diff Legend

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