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.7 by root, Thu Jul 19 02:45:09 2001 UTC vs.
Revision 1.120 by root, Sat Dec 2 18:01:30 2006 UTC

1#include "libcoro/coro.c"
2
1#include "EXTERN.h" 3#include "EXTERN.h"
2#include "perl.h" 4#include "perl.h"
3#include "XSUB.h" 5#include "XSUB.h"
4 6
5#if 1 7#include "patchlevel.h"
6# define CHK(x) (void *)0 8
9#if USE_VALGRIND
10# include <valgrind/valgrind.h>
11#endif
12
13/* the maximum number of idle cctx that will be pooled */
14#define MAX_IDLE_CCTX 8
15
16#define PERL_VERSION_ATLEAST(a,b,c) \
17 (PERL_REVISION > (a) \
18 || (PERL_REVISION == (a) \
19 && (PERL_VERSION > (b) \
20 || (PERL_VERSION == (b) && PERLSUBVERSION >= (c)))))
21
22#if !PERL_VERSION_ATLEAST (5,6,0)
23# ifndef PL_ppaddr
24# define PL_ppaddr ppaddr
25# endif
26# ifndef call_sv
27# define call_sv perl_call_sv
28# endif
29# ifndef get_sv
30# define get_sv perl_get_sv
31# endif
32# ifndef get_cv
33# define get_cv perl_get_cv
34# endif
35# ifndef IS_PADGV
36# define IS_PADGV(v) 0
37# endif
38# ifndef IS_PADCONST
39# define IS_PADCONST(v) 0
40# endif
41#endif
42
43#include <stdio.h>
44#include <errno.h>
45
46#if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64
47# undef STACKGUARD
48#endif
49
50#ifndef STACKGUARD
51# define STACKGUARD 0
52#endif
53
54#ifdef HAVE_MMAP
55# include <unistd.h>
56# include <sys/mman.h>
57# ifndef MAP_ANONYMOUS
58# ifdef MAP_ANON
59# define MAP_ANONYMOUS MAP_ANON
60# else
61# undef HAVE_MMAP
62# endif
63# endif
64# include <limits.h>
65# ifndef PAGESIZE
66# define PAGESIZE pagesize
67# define BOOT_PAGESIZE pagesize = sysconf (_SC_PAGESIZE)
68static long pagesize;
69# else
70# define BOOT_PAGESIZE (void)0
71# endif
7#else 72#else
8# define CHK(x) if (!(x)) croak("FATAL, CHK: " #x) 73# define PAGESIZE 0
74# define BOOT_PAGESIZE (void)0
9#endif 75#endif
10 76
11#define MAY_FLUSH /* increases codesize */ 77/* The next macro should declare a variable stacklevel that contains and approximation
78 * to the current C stack pointer. Its property is that it changes with each call
79 * and should be unique. */
80#define dSTACKLEVEL int stacklevel
81#define STACKLEVEL ((void *)&stacklevel)
12 82
13#define SAVE_DEFAV 0x00000001 83#define IN_DESTRUCT (PL_main_cv == Nullcv)
14#define SAVE_DEFSV 0x00000002
15#define SAVE_ERRSV 0x00000004
16 84
17#define SAVE_ALL -1 85#if __GNUC__ >= 3
86# define attribute(x) __attribute__(x)
87#else
88# define attribute(x)
89#endif
18 90
91#define NOINLINE attribute ((noinline))
92
93#include "CoroAPI.h"
94
95#define TRANSFER_SET_STACKLEVEL 0x8bfbfbfb /* magic cookie */
96
97#ifdef USE_ITHREADS
98static perl_mutex coro_mutex;
99# define LOCK do { MUTEX_LOCK (&coro_mutex); } while (0)
100# define UNLOCK do { MUTEX_UNLOCK (&coro_mutex); } while (0)
101#else
102# define LOCK (void)0
103# define UNLOCK (void)0
104#endif
105
106struct io_state
107{
108 int errorno;
109 I32 laststype;
110 int laststatval;
111 Stat_t statcache;
112};
113
114static struct CoroAPI coroapi;
115static AV *main_mainstack; /* used to differentiate between $main and others */
116static HV *coro_state_stash, *coro_stash;
117static SV *coro_mortal; /* will be freed after next transfer */
118
119static struct coro_cctx *cctx_first;
120static int cctx_count, cctx_idle;
121
122/* this is a structure representing a c-level coroutine */
123typedef struct coro_cctx {
124 struct coro_cctx *next;
125
126 /* the stack */
127 void *sptr;
128 long ssize; /* positive == mmap, otherwise malloc */
129
130 /* cpu state */
131 void *idle_sp; /* sp of top-level transfer/schedule/cede call */
132 JMPENV *top_env;
133 coro_context cctx;
134
135 int inuse;
136
137#if USE_VALGRIND
138 int valgrind_id;
139#endif
140} coro_cctx;
141
142enum {
143 CF_RUNNING = 0x0001, /* coroutine is running */
144 CF_READY = 0x0002, /* coroutine is ready */
145 CF_NEW = 0x0004, /* ahs never been switched to */
146};
147
148/* this is a structure representing a perl-level coroutine */
19struct coro { 149struct coro {
150 /* the c coroutine allocated to this perl coroutine, if any */
151 coro_cctx *cctx;
152
153 /* data associated with this coroutine (initial args) */
154 AV *args;
155 int refcnt;
156 int flags;
157
20 /* optionally saved, might be zero */ 158 /* optionally saved, might be zero */
21 AV *defav; 159 AV *defav;
22 SV *defsv; 160 SV *defsv;
23 SV *errsv; 161 SV *errsv;
24 162
25 /* saved global state not related to stacks */ 163#define VAR(name,type) type name;
26 U8 dowarn; 164# include "state.h"
165#undef VAR
27 166
28 /* the stacks and related info (callchain etc..) */ 167 /* coro process data */
29 PERL_SI *curstackinfo; 168 int prio;
30 AV *curstack;
31 AV *mainstack;
32 SV **stack_sp;
33 OP *op;
34 SV **curpad;
35 SV **stack_base;
36 SV **stack_max;
37 SV **tmps_stack;
38 I32 tmps_floor;
39 I32 tmps_ix;
40 I32 tmps_max;
41 I32 *markstack;
42 I32 *markstack_ptr;
43 I32 *markstack_max;
44 I32 *scopestack;
45 I32 scopestack_ix;
46 I32 scopestack_max;
47 ANY *savestack;
48 I32 savestack_ix;
49 I32 savestack_max;
50 OP **retstack;
51 I32 retstack_ix;
52 I32 retstack_max;
53 COP *curcop;
54
55 /* data associated with this coroutine (initial args) */
56 AV *args;
57}; 169};
58 170
59typedef struct coro *Coro__State; 171typedef struct coro *Coro__State;
60typedef struct coro *Coro__State_or_hashref; 172typedef struct coro *Coro__State_or_hashref;
61 173
62static HV *padlist_cache; 174static AV *
63 175coro_clone_padlist (CV *cv)
64/* mostly copied from op.c:cv_clone2 */
65STATIC AV *
66clone_padlist (AV *protopadlist)
67{ 176{
68 AV *av; 177 AV *padlist = CvPADLIST (cv);
69 I32 ix;
70 AV *protopad_name = (AV *) * av_fetch (protopadlist, 0, FALSE);
71 AV *protopad = (AV *) * av_fetch (protopadlist, 1, FALSE);
72 SV **pname = AvARRAY (protopad_name);
73 SV **ppad = AvARRAY (protopad);
74 I32 fname = AvFILLp (protopad_name);
75 I32 fpad = AvFILLp (protopad);
76 AV *newpadlist, *newpad_name, *newpad; 178 AV *newpadlist, *newpad;
77 SV **npad;
78
79 newpad_name = newAV ();
80 for (ix = fname; ix >= 0; ix--)
81 av_store (newpad_name, ix, SvREFCNT_inc (pname[ix]));
82
83 newpad = newAV ();
84 av_fill (newpad, AvFILLp (protopad));
85 npad = AvARRAY (newpad);
86 179
87 newpadlist = newAV (); 180 newpadlist = newAV ();
88 AvREAL_off (newpadlist); 181 AvREAL_off (newpadlist);
89 av_store (newpadlist, 0, (SV *) newpad_name); 182#if PERL_VERSION_ATLEAST (5,9,0)
183 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1);
184#else
185 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
186#endif
187 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
188 --AvFILLp (padlist);
189
190 av_store (newpadlist, 0, SvREFCNT_inc (*av_fetch (padlist, 0, FALSE)));
90 av_store (newpadlist, 1, (SV *) newpad); 191 av_store (newpadlist, 1, (SV *)newpad);
91 192
92 av = newAV (); /* will be @_ */ 193 return newpadlist;
93 av_extend (av, 0); 194}
94 av_store (newpad, 0, (SV *) av);
95 AvFLAGS (av) = AVf_REIFY;
96 195
97 for (ix = fpad; ix > 0; ix--) 196static void
197free_padlist (AV *padlist)
198{
199 /* may be during global destruction */
200 if (SvREFCNT (padlist))
98 { 201 {
99 SV *namesv = (ix <= fname) ? pname[ix] : Nullsv; 202 I32 i = AvFILLp (padlist);
100 if (namesv && namesv != &PL_sv_undef) 203 while (i >= 0)
101 { 204 {
102 char *name = SvPVX (namesv); /* XXX */ 205 SV **svp = av_fetch (padlist, i--, FALSE);
103 if (SvFLAGS (namesv) & SVf_FAKE || *name == '&') 206 if (svp)
104 { /* lexical from outside? */
105 npad[ix] = SvREFCNT_inc (ppad[ix]);
106 } 207 {
107 else
108 { /* our own lexical */
109 SV *sv; 208 SV *sv;
110 if (*name == '&') 209 while (&PL_sv_undef != (sv = av_pop ((AV *)*svp)))
111 sv = SvREFCNT_inc (ppad[ix]); 210 SvREFCNT_dec (sv);
112 else if (*name == '@') 211
113 sv = (SV *) newAV (); 212 SvREFCNT_dec (*svp);
114 else if (*name == '%')
115 sv = (SV *) newHV ();
116 else
117 sv = NEWSV (0, 0);
118 if (!SvPADBUSY (sv))
119 SvPADMY_on (sv);
120 npad[ix] = sv;
121 } 213 }
122 } 214 }
123 else if (IS_PADGV (ppad[ix]) || IS_PADCONST (ppad[ix])) 215
124 { 216 SvREFCNT_dec ((SV*)padlist);
125 npad[ix] = SvREFCNT_inc (ppad[ix]);
126 }
127 else
128 {
129 SV *sv = NEWSV (0, 0);
130 SvPADTMP_on (sv);
131 npad[ix] = sv;
132 }
133 } 217 }
218}
134 219
135#if 0 /* return -ENOTUNDERSTOOD */ 220static int
136 /* Now that vars are all in place, clone nested closures. */ 221coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
222{
223 AV *padlist;
224 AV *av = (AV *)mg->mg_obj;
137 225
138 for (ix = fpad; ix > 0; ix--) { 226 /* casting is fun. */
139 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv; 227 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
140 if (namesv 228 free_padlist (padlist);
141 && namesv != &PL_sv_undef 229
142 && !(SvFLAGS(namesv) & SVf_FAKE) 230 SvREFCNT_dec (av);
143 && *SvPVX(namesv) == '&' 231
144 && CvCLONE(ppad[ix])) 232 return 0;
145 { 233}
146 CV *kid = cv_clone((CV*)ppad[ix]); 234
147 SvREFCNT_dec(ppad[ix]); 235#define PERL_MAGIC_coro PERL_MAGIC_ext
148 CvCLONE_on(kid); 236
149 SvPADMY_on(kid); 237static MGVTBL vtbl_coro = {0, 0, 0, 0, coro_cv_free};
150 npad[ix] = (SV*)kid; 238
151 } 239#define CORO_MAGIC(cv) \
240 SvMAGIC (cv) \
241 ? SvMAGIC (cv)->mg_type == PERL_MAGIC_coro \
242 ? SvMAGIC (cv) \
243 : mg_find ((SV *)cv, PERL_MAGIC_coro) \
244 : 0
245
246/* the next two functions merely cache the padlists */
247static void
248get_padlist (CV *cv)
249{
250 MAGIC *mg = CORO_MAGIC (cv);
251 AV *av;
252
253 if (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0)
254 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
255 else
256 {
257#if 0
258 /* this is probably cleaner, but also slower? */
259 CV *cp = Perl_cv_clone (cv);
260 CvPADLIST (cv) = CvPADLIST (cp);
261 CvPADLIST (cp) = 0;
262 SvREFCNT_dec (cp);
263#else
264 CvPADLIST (cv) = coro_clone_padlist (cv);
265#endif
266 }
267}
268
269static void
270put_padlist (CV *cv)
271{
272 MAGIC *mg = CORO_MAGIC (cv);
273 AV *av;
274
275 if (!mg)
276 {
277 sv_magic ((SV *)cv, 0, PERL_MAGIC_coro, 0, 0);
278 mg = mg_find ((SV *)cv, PERL_MAGIC_coro);
279 mg->mg_virtual = &vtbl_coro;
280 mg->mg_obj = (SV *)newAV ();
152 } 281 }
153#endif
154 282
155 return newpadlist; 283 av = (AV *)mg->mg_obj;
156}
157 284
158#ifdef MAY_FLUSH 285 if (AvFILLp (av) >= AvMAX (av))
159STATIC AV * 286 av_extend (av, AvMAX (av) + 1);
160free_padlist (AV *padlist)
161{
162 /* may be during global destruction */
163 if (SvREFCNT(padlist))
164 {
165 I32 i = AvFILLp(padlist);
166 while (i >= 0)
167 {
168 SV **svp = av_fetch(padlist, i--, FALSE);
169 SV *sv = svp ? *svp : Nullsv;
170 if (sv)
171 SvREFCNT_dec(sv);
172 }
173 287
174 SvREFCNT_dec((SV*)padlist); 288 AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
175 }
176} 289}
177#endif
178
179/* the next two functions merely cache the padlists */
180STATIC void
181get_padlist (CV *cv)
182{
183 SV **he = hv_fetch (padlist_cache, (void *)&cv, sizeof (CV *), 0);
184
185 if (he && AvFILLp ((AV *)*he) >= 0)
186 CvPADLIST (cv) = (AV *)av_pop ((AV *)*he);
187 else
188 CvPADLIST (cv) = clone_padlist (CvPADLIST (cv));
189}
190
191STATIC void
192put_padlist (CV *cv)
193{
194 SV **he = hv_fetch (padlist_cache, (void *)&cv, sizeof (CV *), 1);
195
196 if (SvTYPE (*he) != SVt_PVAV)
197 {
198 SvREFCNT_dec (*he);
199 *he = (SV *)newAV ();
200 }
201
202 av_push ((AV *)*he, (SV *)CvPADLIST (cv));
203}
204
205#ifdef MAY_FLUSH
206STATIC void
207flush_padlist_cache ()
208{
209 HV *hv = padlist_cache;
210 padlist_cache = newHV ();
211
212 if (hv_iterinit (hv))
213 {
214 HE *he;
215 AV *padlist;
216
217 while (!!(he = hv_iternext (hv)))
218 {
219 AV *av = (AV *)HeVAL(he);
220
221 /* casting is fun. */
222 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
223 free_padlist (padlist);
224 }
225 }
226
227 SvREFCNT_dec (hv);
228}
229#endif
230 290
231#define SB do { 291#define SB do {
232#define SE } while (0) 292#define SE } while (0)
233 293
234#define LOAD(state) SB load_state(aTHX_ state); SPAGAIN; SE 294#define LOAD(state) load_state ((state))
235#define SAVE(state,flags) SB PUTBACK; save_state(aTHX_ state,flags); SE 295#define SAVE(state,flags) save_state ((state),(flags))
236 296
237#define REPLACE_SV(sv,val) SB SvREFCNT_dec(sv); (sv) = (val); SE 297#define REPLACE_SV(sv,val) SB SvREFCNT_dec (sv); (sv) = (val); (val) = 0; SE
238 298
239static void 299static void
240load_state(pTHX_ Coro__State c) 300load_state (Coro__State c)
241{ 301{
242 PL_dowarn = c->dowarn; 302#define VAR(name,type) PL_ ## name = c->name;
243 303# include "state.h"
244 PL_curstackinfo = c->curstackinfo; 304#undef VAR
245 PL_curstack = c->curstack;
246 PL_mainstack = c->mainstack;
247 PL_stack_sp = c->stack_sp;
248 PL_op = c->op;
249 PL_curpad = c->curpad;
250 PL_stack_base = c->stack_base;
251 PL_stack_max = c->stack_max;
252 PL_tmps_stack = c->tmps_stack;
253 PL_tmps_floor = c->tmps_floor;
254 PL_tmps_ix = c->tmps_ix;
255 PL_tmps_max = c->tmps_max;
256 PL_markstack = c->markstack;
257 PL_markstack_ptr = c->markstack_ptr;
258 PL_markstack_max = c->markstack_max;
259 PL_scopestack = c->scopestack;
260 PL_scopestack_ix = c->scopestack_ix;
261 PL_scopestack_max = c->scopestack_max;
262 PL_savestack = c->savestack;
263 PL_savestack_ix = c->savestack_ix;
264 PL_savestack_max = c->savestack_max;
265 PL_retstack = c->retstack;
266 PL_retstack_ix = c->retstack_ix;
267 PL_retstack_max = c->retstack_max;
268 PL_curcop = c->curcop;
269 305
270 if (c->defav) REPLACE_SV (GvAV (PL_defgv), c->defav); 306 if (c->defav) REPLACE_SV (GvAV (PL_defgv), c->defav);
271 if (c->defsv) REPLACE_SV (DEFSV , c->defsv); 307 if (c->defsv) REPLACE_SV (DEFSV , c->defsv);
272 if (c->errsv) REPLACE_SV (ERRSV , c->errsv); 308 if (c->errsv) REPLACE_SV (ERRSV , c->errsv);
273 309
… …
276 CV *cv; 312 CV *cv;
277 313
278 /* now do the ugly restore mess */ 314 /* now do the ugly restore mess */
279 while ((cv = (CV *)POPs)) 315 while ((cv = (CV *)POPs))
280 { 316 {
281 AV *padlist = (AV *)POPs;
282
283 if (padlist)
284 {
285 put_padlist (cv); /* mark this padlist as available */ 317 put_padlist (cv); /* mark this padlist as available */
286 CvPADLIST(cv) = padlist; 318 CvDEPTH (cv) = PTR2IV (POPs);
287#ifdef USE_THREADS 319 CvPADLIST (cv) = (AV *)POPs;
288 /*CvOWNER(cv) = (struct perl_thread *)POPs;*/
289#endif
290 }
291
292 ++CvDEPTH(cv);
293 } 320 }
294 321
295 PUTBACK; 322 PUTBACK;
296 } 323 }
297} 324}
298 325
299static void 326static void
300save_state(pTHX_ Coro__State c, int flags) 327save_state (Coro__State c, int flags)
301{ 328{
302 { 329 {
303 dSP; 330 dSP;
304 I32 cxix = cxstack_ix; 331 I32 cxix = cxstack_ix;
332 PERL_CONTEXT *ccstk = cxstack;
305 PERL_SI *top_si = PL_curstackinfo; 333 PERL_SI *top_si = PL_curstackinfo;
306 PERL_CONTEXT *ccstk = cxstack;
307 334
308 /* 335 /*
309 * the worst thing you can imagine happens first - we have to save 336 * the worst thing you can imagine happens first - we have to save
310 * (and reinitialize) all cv's in the whole callchain :( 337 * (and reinitialize) all cv's in the whole callchain :(
311 */ 338 */
312 339
313 PUSHs (Nullsv); 340 PUSHs (Nullsv);
314 /* this loop was inspired by pp_caller */ 341 /* this loop was inspired by pp_caller */
315 for (;;) 342 for (;;)
316 { 343 {
317 do 344 while (cxix >= 0)
318 { 345 {
319 PERL_CONTEXT *cx = &ccstk[cxix--]; 346 PERL_CONTEXT *cx = &ccstk[cxix--];
320 347
321 if (CxTYPE(cx) == CXt_SUB) 348 if (CxTYPE (cx) == CXt_SUB)
322 { 349 {
323 CV *cv = cx->blk_sub.cv; 350 CV *cv = cx->blk_sub.cv;
351
324 if (CvDEPTH(cv)) 352 if (CvDEPTH (cv))
325 { 353 {
326#ifdef USE_THREADS
327 /*XPUSHs ((SV *)CvOWNER(cv));*/
328 /*CvOWNER(cv) = 0;*/
329 /*error must unlock this cv etc.. etc...*/
330#endif
331 EXTEND (SP, CvDEPTH(cv)*2); 354 EXTEND (SP, 3);
332 355
333 while (--CvDEPTH(cv))
334 {
335 /* this tells the restore code to increment CvDEPTH */
336 PUSHs (Nullsv);
337 PUSHs ((SV *)cv);
338 }
339
340 PUSHs ((SV *)CvPADLIST(cv)); 356 PUSHs ((SV *)CvPADLIST (cv));
357 PUSHs (INT2PTR (SV *, CvDEPTH (cv)));
341 PUSHs ((SV *)cv); 358 PUSHs ((SV *)cv);
342 359
360 CvDEPTH (cv) = 0;
343 get_padlist (cv); /* this is a monster */ 361 get_padlist (cv);
344 } 362 }
345 } 363 }
364#ifdef CXt_FORMAT
346 else if (CxTYPE(cx) == CXt_FORMAT) 365 else if (CxTYPE (cx) == CXt_FORMAT)
347 { 366 {
348 /* I never used formats, so how should I know how these are implemented? */ 367 /* I never used formats, so how should I know how these are implemented? */
349 /* my bold guess is as a simple, plain sub... */ 368 /* my bold guess is as a simple, plain sub... */
350 croak ("CXt_FORMAT not yet handled. Don't switch coroutines from within formats"); 369 croak ("CXt_FORMAT not yet handled. Don't switch coroutines from within formats");
351 } 370 }
371#endif
352 } 372 }
353 while (cxix >= 0);
354 373
355 if (top_si->si_type == PERLSI_MAIN) 374 if (top_si->si_type == PERLSI_MAIN)
356 break; 375 break;
357 376
358 top_si = top_si->si_prev; 377 top_si = top_si->si_prev;
… …
361 } 380 }
362 381
363 PUTBACK; 382 PUTBACK;
364 } 383 }
365 384
366 c->defav = flags & SAVE_DEFAV ? (AV *)SvREFCNT_inc (GvAV (PL_defgv)) : 0; 385 c->defav = flags & TRANSFER_SAVE_DEFAV ? (AV *)SvREFCNT_inc (GvAV (PL_defgv)) : 0;
367 c->defsv = flags & SAVE_DEFSV ? SvREFCNT_inc (DEFSV) : 0; 386 c->defsv = flags & TRANSFER_SAVE_DEFSV ? SvREFCNT_inc (DEFSV) : 0;
368 c->errsv = flags & SAVE_ERRSV ? SvREFCNT_inc (ERRSV) : 0; 387 c->errsv = flags & TRANSFER_SAVE_ERRSV ? SvREFCNT_inc (ERRSV) : 0;
369 388
370 c->dowarn = PL_dowarn; 389#define VAR(name,type)c->name = PL_ ## name;
390# include "state.h"
391#undef VAR
392}
371 393
372 c->curstackinfo = PL_curstackinfo; 394/*
373 c->curstack = PL_curstack; 395 * allocate various perl stacks. This is an exact copy
374 c->mainstack = PL_mainstack; 396 * of perl.c:init_stacks, except that it uses less memory
375 c->stack_sp = PL_stack_sp; 397 * on the (sometimes correct) assumption that coroutines do
376 c->op = PL_op; 398 * not usually need a lot of stackspace.
377 c->curpad = PL_curpad; 399 */
400static void
401coro_init_stacks ()
402{
403 PL_curstackinfo = new_stackinfo(128, 1024/sizeof(PERL_CONTEXT));
404 PL_curstackinfo->si_type = PERLSI_MAIN;
405 PL_curstack = PL_curstackinfo->si_stack;
406 PL_mainstack = PL_curstack; /* remember in case we switch stacks */
407
408 PL_stack_base = AvARRAY(PL_curstack);
378 c->stack_base = PL_stack_base; 409 PL_stack_sp = PL_stack_base;
379 c->stack_max = PL_stack_max; 410 PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
380 c->tmps_stack = PL_tmps_stack; 411
381 c->tmps_floor = PL_tmps_floor; 412 New(50,PL_tmps_stack,128,SV*);
382 c->tmps_ix = PL_tmps_ix; 413 PL_tmps_floor = -1;
383 c->tmps_max = PL_tmps_max; 414 PL_tmps_ix = -1;
415 PL_tmps_max = 128;
416
417 New(54,PL_markstack,32,I32);
384 c->markstack = PL_markstack; 418 PL_markstack_ptr = PL_markstack;
385 c->markstack_ptr = PL_markstack_ptr; 419 PL_markstack_max = PL_markstack + 32;
386 c->markstack_max = PL_markstack_max; 420
387 c->scopestack = PL_scopestack; 421#ifdef SET_MARK_OFFSET
388 c->scopestack_ix = PL_scopestack_ix; 422 SET_MARK_OFFSET;
389 c->scopestack_max = PL_scopestack_max; 423#endif
390 c->savestack = PL_savestack; 424
391 c->savestack_ix = PL_savestack_ix; 425 New(54,PL_scopestack,32,I32);
392 c->savestack_max = PL_savestack_max; 426 PL_scopestack_ix = 0;
393 c->retstack = PL_retstack; 427 PL_scopestack_max = 32;
394 c->retstack_ix = PL_retstack_ix; 428
395 c->retstack_max = PL_retstack_max; 429 New(54,PL_savestack,64,ANY);
396 c->curcop = PL_curcop; 430 PL_savestack_ix = 0;
431 PL_savestack_max = 64;
432
433#if !PERL_VERSION_ATLEAST (5,9,0)
434 New(54,PL_retstack,16,OP*);
435 PL_retstack_ix = 0;
436 PL_retstack_max = 16;
437#endif
397} 438}
398 439
399/* 440/*
400 * destroy the stacks, the callchain etc... 441 * destroy the stacks, the callchain etc...
401 * still there is a memleak of 128 bytes...
402 */ 442 */
403STATIC void 443static void
404destroy_stacks(pTHX) 444coro_destroy_stacks ()
405{ 445{
446 if (!IN_DESTRUCT)
447 {
406 /* is this ugly, I ask? */ 448 /* is this ugly, I ask? */
407 while (PL_scopestack_ix) 449 LEAVE_SCOPE (0);
408 LEAVE;
409 450
410 /* sure it is, but more important: is it correct?? :/ */ 451 /* sure it is, but more important: is it correct?? :/ */
411 while (PL_tmps_ix > PL_tmps_floor) /* should only ever be one iteration */
412 FREETMPS; 452 FREETMPS;
453
454 /*POPSTACK_TO (PL_mainstack);*//*D*//*use*/
455 }
413 456
414 while (PL_curstackinfo->si_next) 457 while (PL_curstackinfo->si_next)
415 PL_curstackinfo = PL_curstackinfo->si_next; 458 PL_curstackinfo = PL_curstackinfo->si_next;
416 459
417 while (PL_curstackinfo) 460 while (PL_curstackinfo)
418 { 461 {
419 PERL_SI *p = PL_curstackinfo->si_prev; 462 PERL_SI *p = PL_curstackinfo->si_prev;
420 463
421 { 464 { /*D*//*remove*/
422 dSP; 465 dSP;
423 SWITCHSTACK (PL_curstack, PL_curstackinfo->si_stack); 466 SWITCHSTACK (PL_curstack, PL_curstackinfo->si_stack);
424 PUTBACK; /* possibly superfluous */ 467 PUTBACK; /* possibly superfluous */
425 } 468 }
426 469
427 dounwind(-1); 470 if (!IN_DESTRUCT)
428 471 {
472 dounwind (-1);/*D*//*remove*/
429 SvREFCNT_dec(PL_curstackinfo->si_stack); 473 SvREFCNT_dec (PL_curstackinfo->si_stack);
474 }
475
430 Safefree(PL_curstackinfo->si_cxstack); 476 Safefree (PL_curstackinfo->si_cxstack);
431 Safefree(PL_curstackinfo); 477 Safefree (PL_curstackinfo);
432 PL_curstackinfo = p; 478 PL_curstackinfo = p;
433 } 479 }
434 480
435 Safefree(PL_tmps_stack); 481 Safefree (PL_tmps_stack);
436 Safefree(PL_markstack); 482 Safefree (PL_markstack);
437 Safefree(PL_scopestack); 483 Safefree (PL_scopestack);
438 Safefree(PL_savestack); 484 Safefree (PL_savestack);
485#if !PERL_VERSION_ATLEAST (5,9,0)
439 Safefree(PL_retstack); 486 Safefree (PL_retstack);
487#endif
440} 488}
441 489
442#define SUB_INIT "Coro::State::_newcoro" 490static void
491setup_coro (struct coro *coro)
492{
493 /*
494 * emulate part of the perl startup here.
495 */
496
497 coro_init_stacks ();
498
499 PL_curcop = &PL_compiling;
500 PL_in_eval = EVAL_NULL;
501 PL_curpm = 0;
502 PL_localizing = 0;
503 PL_dirty = 0;
504 PL_restartop = 0;
505
506 {
507 dSP;
508 LOGOP myop;
509
510 SvREFCNT_dec (GvAV (PL_defgv));
511 GvAV (PL_defgv) = coro->args; coro->args = 0;
512
513 Zero (&myop, 1, LOGOP);
514 myop.op_next = Nullop;
515 myop.op_flags = OPf_WANT_VOID;
516
517 PUSHMARK (SP);
518 XPUSHs ((SV *)get_cv ("Coro::State::_coro_init", FALSE));
519 PUTBACK;
520 PL_op = (OP *)&myop;
521 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
522 SPAGAIN;
523 }
524
525 ENTER; /* necessary e.g. for dounwind */
526}
527
528static void
529free_coro_mortal ()
530{
531 if (coro_mortal)
532 {
533 SvREFCNT_dec (coro_mortal);
534 coro_mortal = 0;
535 }
536}
537
538/* inject a fake call to Coro::State::_cctx_init into the execution */
539static void NOINLINE
540prepare_cctx (coro_cctx *cctx)
541{
542 dSP;
543 LOGOP myop;
544
545 Zero (&myop, 1, LOGOP);
546 myop.op_next = PL_op;
547 myop.op_flags = OPf_WANT_VOID | OPf_STACKED;
548
549 PUSHMARK (SP);
550 EXTEND (SP, 2);
551 PUSHs (sv_2mortal (newSViv (PTR2IV (cctx))));
552 PUSHs ((SV *)get_cv ("Coro::State::_cctx_init", FALSE));
553 PUTBACK;
554 PL_op = (OP *)&myop;
555 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
556 SPAGAIN;
557}
558
559static void
560coro_run (void *arg)
561{
562 /* coro_run is the alternative tail of transfer(), so unlock here. */
563 UNLOCK;
564
565 /*
566 * this is a _very_ stripped down perl interpreter ;)
567 */
568 PL_top_env = &PL_start_env;
569
570 /* inject call to cctx_init */
571 prepare_cctx ((coro_cctx *)arg);
572
573 /* somebody will hit me for both perl_run and PL_restartop */
574 PL_restartop = PL_op;
575 perl_run (PL_curinterp);
576
577 fputs ("FATAL: C coroutine fell over the edge of the world, aborting. Did you call exit in a coroutine?\n", stderr);
578 abort ();
579}
580
581static coro_cctx *
582cctx_new ()
583{
584 coro_cctx *cctx;
585
586 ++cctx_count;
587
588 New (0, cctx, 1, coro_cctx);
589
590#if HAVE_MMAP
591
592 cctx->ssize = ((STACKSIZE * sizeof (long) + PAGESIZE - 1) / PAGESIZE + STACKGUARD) * PAGESIZE;
593 /* mmap supposedly does allocate-on-write for us */
594 cctx->sptr = mmap (0, cctx->ssize, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
595
596 if (cctx->sptr == (void *)-1)
597 {
598 perror ("FATAL: unable to mmap stack for coroutine");
599 _exit (EXIT_FAILURE);
600 }
601
602# if STACKGUARD
603 mprotect (cctx->sptr, STACKGUARD * PAGESIZE, PROT_NONE);
604# endif
605
606#else
607
608 cctx->ssize = STACKSIZE * (long)sizeof (long);
609 New (0, cctx->sptr, STACKSIZE, long);
610
611 if (!cctx->sptr)
612 {
613 perror ("FATAL: unable to malloc stack for coroutine");
614 _exit (EXIT_FAILURE);
615 }
616
617#endif
618
619#if USE_VALGRIND
620 cctx->valgrind_id = VALGRIND_STACK_REGISTER (
621 STACKGUARD * PAGESIZE + (char *)cctx->sptr,
622 cctx->ssize + (char *)cctx->sptr
623 );
624#endif
625
626 coro_create (&cctx->cctx, coro_run, (void *)cctx, cctx->sptr, cctx->ssize);
627
628 return cctx;
629}
630
631static void
632cctx_destroy (coro_cctx *cctx)
633{
634 if (!cctx)
635 return;
636
637 --cctx_count;
638
639#if USE_VALGRIND
640 VALGRIND_STACK_DEREGISTER (cctx->valgrind_id);
641#endif
642
643#if HAVE_MMAP
644 munmap (cctx->sptr, cctx->ssize);
645#else
646 Safefree (cctx->sptr);
647#endif
648
649 Safefree (cctx);
650}
651
652static coro_cctx *
653cctx_get ()
654{
655 coro_cctx *cctx;
656
657 if (cctx_first)
658 {
659 cctx = cctx_first;
660 cctx_first = cctx->next;
661 --cctx_idle;
662 }
663 else
664 {
665 cctx = cctx_new ();
666 PL_op = PL_op->op_next;
667 }
668
669 return cctx;
670}
671
672static void
673cctx_put (coro_cctx *cctx)
674{
675 /* free another cctx if overlimit */
676 if (cctx_idle >= MAX_IDLE_CCTX)
677 {
678 coro_cctx *first = cctx_first;
679 cctx_first = first->next;
680 --cctx_idle;
681
682 assert (!first->inuse);
683 cctx_destroy (first);
684 }
685
686 ++cctx_idle;
687 cctx->next = cctx_first;
688 cctx_first = cctx;
689}
690
691/* never call directly, always through the coro_state_transfer global variable */
692static void NOINLINE
693transfer (struct coro *prev, struct coro *next, int flags)
694{
695 dSTACKLEVEL;
696
697 /* sometimes transfer is only called to set idle_sp */
698 if (flags == TRANSFER_SET_STACKLEVEL)
699 ((coro_cctx *)prev)->idle_sp = STACKLEVEL;
700 else if (prev != next)
701 {
702 coro_cctx *prev__cctx;
703
704 if (prev->flags & CF_NEW)
705 {
706 /* create a new empty context */
707 Newz (0, prev->cctx, 1, coro_cctx);
708 prev->cctx->inuse = 1;
709 prev->flags &= ~CF_NEW;
710 prev->flags |= CF_RUNNING;
711 }
712
713 /*TODO: must not croak here */
714 if (!prev->flags & CF_RUNNING)
715 croak ("Coro::State::transfer called with non-running prev Coro::State, but can only transfer from running states");
716
717 if (next->flags & CF_RUNNING)
718 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states");
719
720 prev->flags &= ~CF_RUNNING;
721 next->flags |= CF_RUNNING;
722
723 LOCK;
724
725 if (next->flags & CF_NEW)
726 {
727 /* need to start coroutine */
728 next->flags &= ~CF_NEW;
729 /* first get rid of the old state */
730 SAVE (prev, -1);
731 /* setup coroutine call */
732 setup_coro (next);
733 /* need a new stack */
734 assert (!next->stack);
735 }
736 else
737 {
738 /* coroutine already started */
739 SAVE (prev, flags);
740 LOAD (next);
741 }
742
743 prev__cctx = prev->cctx;
744
745 /* possibly "free" the cctx */
746 if (prev__cctx->idle_sp == STACKLEVEL)
747 {
748 /* I assume that STACKLEVEL is a stronger indicator than PL_top_env changes */
749 assert (PL_top_env == prev__cctx->top_env);
750
751 prev->cctx = 0;
752
753 cctx_put (prev__cctx);
754 prev__cctx->inuse = 0;
755 }
756
757 if (!next->cctx)
758 {
759 next->cctx = cctx_get ();
760 assert (!next->cctx->inuse);
761 next->cctx->inuse = 1;
762 }
763
764 if (prev__cctx != next->cctx)
765 {
766 prev__cctx->top_env = PL_top_env;
767 PL_top_env = next->cctx->top_env;
768 coro_transfer (&prev__cctx->cctx, &next->cctx->cctx);
769 }
770
771 free_coro_mortal ();
772
773 UNLOCK;
774 }
775}
776
777struct transfer_args
778{
779 struct coro *prev, *next;
780 int flags;
781};
782
783#define TRANSFER(ta) transfer ((ta).prev, (ta).next, (ta).flags)
784
785static void
786coro_state_destroy (struct coro *coro)
787{
788 if (coro->refcnt--)
789 return;
790
791 if (coro->mainstack && coro->mainstack != main_mainstack)
792 {
793 struct coro temp;
794
795 if (coro->flags & CF_RUNNING)
796 croak ("FATAL: tried to destroy currently running coroutine");
797
798 SAVE ((&temp), TRANSFER_SAVE_ALL);
799 LOAD (coro);
800
801 coro_destroy_stacks ();
802
803 LOAD ((&temp)); /* this will get rid of defsv etc.. */
804
805 coro->mainstack = 0;
806 }
807
808 cctx_destroy (coro->cctx);
809 SvREFCNT_dec (coro->args);
810 Safefree (coro);
811}
812
813static int
814coro_state_clear (pTHX_ SV *sv, MAGIC *mg)
815{
816 struct coro *coro = (struct coro *)mg->mg_ptr;
817 mg->mg_ptr = 0;
818
819 coro_state_destroy (coro);
820
821 return 0;
822}
823
824static int
825coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
826{
827 struct coro *coro = (struct coro *)mg->mg_ptr;
828
829 ++coro->refcnt;
830
831 return 0;
832}
833
834static MGVTBL coro_state_vtbl = {
835 0, 0, 0, 0,
836 coro_state_clear,
837 0,
838#ifdef MGf_DUP
839 coro_state_dup,
840#else
841# define MGf_DUP 0
842#endif
843};
844
845static struct coro *
846SvSTATE (SV *coro)
847{
848 HV *stash;
849 MAGIC *mg;
850
851 if (SvROK (coro))
852 coro = SvRV (coro);
853
854 stash = SvSTASH (coro);
855 if (stash != coro_stash && stash != coro_state_stash)
856 {
857 /* very slow, but rare, check */
858 if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
859 croak ("Coro::State object required");
860 }
861
862 mg = SvMAGIC (coro);
863 assert (mg->mg_type == PERL_MAGIC_ext);
864 return (struct coro *)mg->mg_ptr;
865}
866
867static void
868prepare_transfer (struct transfer_args *ta, SV *prev, SV *next, int flags)
869{
870 ta->prev = SvSTATE (prev);
871 ta->next = SvSTATE (next);
872 ta->flags = flags;
873}
874
875static void
876api_transfer (SV *prev, SV *next, int flags)
877{
878 struct transfer_args ta;
879
880 prepare_transfer (&ta, prev, next, flags);
881 TRANSFER (ta);
882}
883
884/** Coro ********************************************************************/
885
886#define PRIO_MAX 3
887#define PRIO_HIGH 1
888#define PRIO_NORMAL 0
889#define PRIO_LOW -1
890#define PRIO_IDLE -3
891#define PRIO_MIN -4
892
893/* for Coro.pm */
894static SV *coro_current;
895static AV *coro_ready [PRIO_MAX-PRIO_MIN+1];
896static int coro_nready;
897
898static void
899coro_enq (SV *coro_sv)
900{
901 av_push (coro_ready [SvSTATE (coro_sv)->prio - PRIO_MIN], coro_sv);
902 coro_nready++;
903}
904
905static SV *
906coro_deq (int min_prio)
907{
908 int prio = PRIO_MAX - PRIO_MIN;
909
910 min_prio -= PRIO_MIN;
911 if (min_prio < 0)
912 min_prio = 0;
913
914 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= min_prio; )
915 if (AvFILLp (coro_ready [prio]) >= 0)
916 {
917 coro_nready--;
918 return av_shift (coro_ready [prio]);
919 }
920
921 return 0;
922}
923
924static int
925api_ready (SV *coro_sv)
926{
927 struct coro *coro;
928
929 if (SvROK (coro_sv))
930 coro_sv = SvRV (coro_sv);
931
932 coro = SvSTATE (coro_sv);
933
934 if (coro->flags & CF_READY)
935 return 0;
936
937#if 0 /* this is actually harmless */
938 if (coro->flags & CF_RUNNING)
939 croak ("Coro::ready called on currently running coroutine");
940#endif
941
942 coro->flags |= CF_READY;
943
944 LOCK;
945 coro_enq (SvREFCNT_inc (coro_sv));
946 UNLOCK;
947
948 return 1;
949}
950
951static int
952api_is_ready (SV *coro_sv)
953{
954 return !!SvSTATE (coro_sv)->flags & CF_READY;
955}
956
957static void
958prepare_schedule (struct transfer_args *ta)
959{
960 SV *prev, *next;
961
962 for (;;)
963 {
964 LOCK;
965 next = coro_deq (PRIO_MIN);
966 UNLOCK;
967
968 if (next)
969 break;
970
971 {
972 dSP;
973
974 ENTER;
975 SAVETMPS;
976
977 PUSHMARK (SP);
978 PUTBACK;
979 call_sv (get_sv ("Coro::idle", FALSE), G_DISCARD);
980
981 FREETMPS;
982 LEAVE;
983 }
984 }
985
986 prev = SvRV (coro_current);
987 SvRV_set (coro_current, next);
988
989 /* free this only after the transfer */
990 LOCK;
991 free_coro_mortal ();
992 UNLOCK;
993 coro_mortal = prev;
994
995 assert (!SvROK(prev));//D
996 assert (!SvROK(next));//D
997
998 ta->prev = SvSTATE (prev);
999 ta->next = SvSTATE (next);
1000 ta->flags = TRANSFER_SAVE_ALL;
1001
1002 assert (ta->flags & CF_READY);
1003 ta->next->flags &= ~CF_READY;
1004}
1005
1006static void
1007prepare_cede (struct transfer_args *ta)
1008{
1009 api_ready (coro_current);
1010
1011 prepare_schedule (ta);
1012}
1013
1014static void
1015api_schedule (void)
1016{
1017 struct transfer_args ta;
1018
1019 prepare_schedule (&ta);
1020 TRANSFER (ta);
1021}
1022
1023static void
1024api_cede (void)
1025{
1026 struct transfer_args ta;
1027
1028 prepare_cede (&ta);
1029 TRANSFER (ta);
1030}
443 1031
444MODULE = Coro::State PACKAGE = Coro::State 1032MODULE = Coro::State PACKAGE = Coro::State
445 1033
446PROTOTYPES: ENABLE 1034PROTOTYPES: DISABLE
447 1035
448BOOT: 1036BOOT:
1037{
1038#ifdef USE_ITHREADS
1039 MUTEX_INIT (&coro_mutex);
1040#endif
1041 BOOT_PAGESIZE;
1042
449 HV * stash = gv_stashpvn("Coro::State", 10, TRUE); 1043 coro_state_stash = gv_stashpv ("Coro::State", TRUE);
450 1044
451 newCONSTSUB (stash, "SAVE_DEFAV", newSViv (SAVE_DEFAV)); 1045 newCONSTSUB (coro_state_stash, "SAVE_DEFAV", newSViv (TRANSFER_SAVE_DEFAV));
452 newCONSTSUB (stash, "SAVE_DEFSV", newSViv (SAVE_DEFSV)); 1046 newCONSTSUB (coro_state_stash, "SAVE_DEFSV", newSViv (TRANSFER_SAVE_DEFSV));
453 newCONSTSUB (stash, "SAVE_ERRSV", newSViv (SAVE_ERRSV)); 1047 newCONSTSUB (coro_state_stash, "SAVE_ERRSV", newSViv (TRANSFER_SAVE_ERRSV));
454 1048
455 if (!padlist_cache) 1049 main_mainstack = PL_mainstack;
456 padlist_cache = newHV ();
457 1050
458Coro::State 1051 coroapi.ver = CORO_API_VERSION;
459_newprocess(args) 1052 coroapi.transfer = api_transfer;
460 SV * args 1053
461 PROTOTYPE: $ 1054 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
1055}
1056
1057SV *
1058new (char *klass, ...)
462 CODE: 1059 CODE:
463 Coro__State coro; 1060{
1061 struct coro *coro;
1062 HV *hv;
1063 int i;
464 1064
465 if (!SvROK (args) || SvTYPE (SvRV (args)) != SVt_PVAV)
466 croak ("Coro::State::_newprocess expects an arrayref");
467
468 New (0, coro, 1, struct coro); 1065 Newz (0, coro, 1, struct coro);
1066 coro->args = newAV ();
1067 coro->flags = CF_NEW;
469 1068
470 coro->mainstack = 0; /* actual work is done inside transfer */ 1069 hv = newHV ();
471 coro->args = (AV *)SvREFCNT_inc (SvRV (args)); 1070 sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, &coro_state_vtbl, (char *)coro, 0)->mg_flags |= MGf_DUP;
1071 RETVAL = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
472 1072
473 RETVAL = coro; 1073 for (i = 1; i < items; i++)
1074 av_push (coro->args, newSVsv (ST (i)));
1075}
474 OUTPUT: 1076 OUTPUT:
475 RETVAL 1077 RETVAL
476 1078
477void 1079void
478transfer(prev, next, flags = SAVE_DEFAV) 1080_set_stacklevel (...)
479 Coro::State_or_hashref prev 1081 ALIAS:
480 Coro::State_or_hashref next 1082 Coro::State::transfer = 1
481 int flags 1083 Coro::schedule = 2
1084 Coro::cede = 3
482 CODE: 1085 CODE:
1086{
1087 struct transfer_args ta;
483 1088
484 if (prev != next) 1089 switch (ix)
485 { 1090 {
486 /*
487 * this could be done in newprocess which would lead to
488 * extremely elegant and fast (just SAVE/LOAD)
489 * code here, but lazy allocation of stacks has also
490 * some virtues and the overhead of the if() is nil.
491 */
492 if (next->mainstack)
493 {
494 SAVE (prev, flags);
495 LOAD (next);
496 /* mark this state as in-use */
497 next->mainstack = 0;
498 next->tmps_ix = -2;
499 }
500 else if (next->tmps_ix == -2)
501 {
502 croak ("tried to transfer to running coroutine");
503 }
504 else 1091 case 0:
1092 ta.prev = (struct coro *)INT2PTR (coro_cctx *, SvIV (ST (0)));
1093 ta.next = 0;
1094 ta.flags = TRANSFER_SET_STACKLEVEL;
505 { 1095 break;
506 /*
507 * emulate part of the perl startup here.
508 */
509 UNOP myop;
510 1096
511 SAVE (prev, -1); /* first get rid of the old state */ 1097 case 1:
1098 if (items != 3)
1099 croak ("Coro::State::transfer (prev,next,flags) expects three arguments, not %d", items);
512 1100
513 init_stacks (); /* from perl.c */ 1101 prepare_transfer (&ta, ST (0), ST (1), SvIV (ST (2)));
514 SPAGAIN;
515
516 PL_op = (OP *)&myop;
517 /*PL_curcop = 0;*/
518 SvREFCNT_dec (GvAV (PL_defgv));
519 GvAV (PL_defgv) = next->args;
520
521 Zero(&myop, 1, UNOP);
522 myop.op_next = Nullop;
523 myop.op_flags = OPf_WANT_VOID;
524
525 PUSHMARK(SP);
526 XPUSHs ((SV*)get_cv(SUB_INIT, TRUE));
527 /*
528 * the next line is slightly wrong, as PL_op->op_next
529 * is actually being executed so we skip the first op.
530 * that doesn't matter, though, since it is only
531 * pp_nextstate and we never return...
532 * ah yes, and I don't care anyways ;)
533 */
534 PUTBACK;
535 PL_op = pp_entersub(aTHX);
536 SPAGAIN;
537
538 ENTER; /* necessary e.g. for dounwind */
539 } 1102 break;
1103
1104 case 2:
1105 prepare_schedule (&ta);
1106 break;
1107
1108 case 3:
1109 prepare_cede (&ta);
1110 break;
540 } 1111 }
541 1112
1113 TRANSFER (ta);
1114}
1115
542void 1116void
543DESTROY(coro) 1117_clone_state_from (SV *dst, SV *src)
544 Coro::State coro 1118 CODE:
1119{
1120 struct coro *coro_src = SvSTATE (src);
1121
1122 sv_unmagic (SvRV (dst), PERL_MAGIC_ext);
1123
1124 ++coro_src->refcnt;
1125 sv_magicext (SvRV (dst), 0, PERL_MAGIC_ext, &coro_state_vtbl, (char *)coro_src, 0)->mg_flags |= MGf_DUP;
1126}
1127
1128void
1129_exit (code)
1130 int code
1131 PROTOTYPE: $
1132 CODE:
1133 _exit (code);
1134
1135int
1136cctx_count ()
1137 CODE:
1138 RETVAL = cctx_count;
1139 OUTPUT:
1140 RETVAL
1141
1142int
1143cctx_idle ()
1144 CODE:
1145 RETVAL = cctx_idle;
1146 OUTPUT:
1147 RETVAL
1148
1149MODULE = Coro::State PACKAGE = Coro
1150
1151BOOT:
1152{
1153 int i;
1154
1155 coro_stash = gv_stashpv ("Coro", TRUE);
1156
1157 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
1158 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
1159 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
1160 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
1161 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
1162 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
1163
1164 coro_current = get_sv ("Coro::current", FALSE);
1165 SvREADONLY_on (coro_current);
1166
1167 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
1168 coro_ready[i] = newAV ();
1169
1170 {
1171 SV *sv = perl_get_sv("Coro::API", 1);
1172
1173 coroapi.schedule = api_schedule;
1174 coroapi.cede = api_cede;
1175 coroapi.ready = api_ready;
1176 coroapi.is_ready = api_is_ready;
1177 coroapi.nready = &coro_nready;
1178 coroapi.current = coro_current;
1179
1180 GCoroAPI = &coroapi;
1181 sv_setiv (sv, (IV)&coroapi);
1182 SvREADONLY_on (sv);
1183 }
1184}
1185
1186int
1187prio (Coro::State coro, int newprio = 0)
1188 ALIAS:
1189 nice = 1
545 CODE: 1190 CODE:
1191{
1192 RETVAL = coro->prio;
546 1193
547 if (coro->mainstack) 1194 if (items > 1)
548 { 1195 {
549 struct coro temp; 1196 if (ix)
1197 newprio += coro->prio;
550 1198
551 SAVE(aTHX_ (&temp), SAVE_ALL); 1199 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
552 LOAD(aTHX_ coro); 1200 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
553 1201
554 destroy_stacks (); 1202 coro->prio = newprio;
555
556 LOAD((&temp)); /* this will get rid of defsv etc.. */
557 } 1203 }
1204}
558 1205
559 Safefree (coro); 1206SV *
1207ready (SV *self)
1208 PROTOTYPE: $
1209 CODE:
1210 RETVAL = boolSV (api_ready (self));
1211 OUTPUT:
1212 RETVAL
1213
1214SV *
1215is_ready (SV *self)
1216 PROTOTYPE: $
1217 CODE:
1218 RETVAL = boolSV (api_is_ready (self));
1219 OUTPUT:
1220 RETVAL
1221
1222int
1223nready (...)
1224 PROTOTYPE:
1225 CODE:
1226 RETVAL = coro_nready;
1227 OUTPUT:
1228 RETVAL
560 1229
561void 1230void
562flush() 1231_set_current (SV *current)
1232 PROTOTYPE: $
563 CODE: 1233 CODE:
564#ifdef MAY_FLUSH 1234 SvREFCNT_dec (SvRV (coro_current));
565 flush_padlist_cache (); 1235 SvRV_set (coro_current, SvREFCNT_inc (SvRV (current)));
566#endif
567 1236
1237MODULE = Coro::State PACKAGE = Coro::AIO
568 1238
1239SV *
1240_get_state ()
1241 CODE:
1242{
1243 RETVAL = newSV (sizeof (struct io_state));
1244 struct io_state *data = (struct io_state *)SvPVX (RETVAL);
1245 SvCUR_set (RETVAL, sizeof (struct io_state));
1246 SvPOK_only (RETVAL);
1247
1248 data->errorno = errno;
1249 data->laststype = PL_laststype;
1250 data->laststatval = PL_laststatval;
1251 data->statcache = PL_statcache;
1252}
1253 OUTPUT:
1254 RETVAL
1255
1256void
1257_set_state (char *data_)
1258 PROTOTYPE: $
1259 CODE:
1260{
1261 struct io_state *data = (void *)data_;
1262
1263 errno = data->errorno;
1264 PL_laststype = data->laststype;
1265 PL_laststatval = data->laststatval;
1266 PL_statcache = data->statcache;
1267}
1268

Diff Legend

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