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.352 by root, Sat Jun 20 08:58:50 2009 UTC vs.
Revision 1.360 by root, Mon Jun 29 06:14:23 2009 UTC

… …
137 137
138#define IN_DESTRUCT PL_dirty 138#define IN_DESTRUCT PL_dirty
139 139
140#if __GNUC__ >= 3 140#if __GNUC__ >= 3
141# define attribute(x) __attribute__(x) 141# define attribute(x) __attribute__(x)
142# define expect(expr,value) __builtin_expect ((expr),(value)) 142# define expect(expr,value) __builtin_expect ((expr), (value))
143# define INLINE static inline 143# define INLINE static inline
144#else 144#else
145# define attribute(x) 145# define attribute(x)
146# define expect(expr,value) (expr) 146# define expect(expr,value) (expr)
147# define INLINE static 147# define INLINE static
… …
159# if CORO_PTHREAD 159# if CORO_PTHREAD
160static void *coro_thx; 160static void *coro_thx;
161# endif 161# endif
162#endif 162#endif
163 163
164#ifdef __linux
165# include <time.h> /* for timespec */
166# include <syscall.h> /* for SYS_* */
167# ifdef SYS_clock_gettime
168# define coro_clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
169# define CORO_CLOCK_MONOTONIC 1
170# define CORO_CLOCK_THREAD_CPUTIME_ID 3
171# endif
172#endif
173
164static double (*nvtime)(); /* so why doesn't it take void? */ 174static double (*nvtime)(); /* so why doesn't it take void? */
175static void (*u2time)(pTHX_ UV ret[2]);
165 176
166/* we hijack an hopefully unused CV flag for our purposes */ 177/* we hijack an hopefully unused CV flag for our purposes */
167#define CVf_SLF 0x4000 178#define CVf_SLF 0x4000
168static OP *pp_slf (pTHX); 179static OP *pp_slf (pTHX);
169 180
… …
194static CV *cv_pool_handler; 205static CV *cv_pool_handler;
195static CV *cv_coro_state_new; 206static CV *cv_coro_state_new;
196 207
197/* Coro::AnyEvent */ 208/* Coro::AnyEvent */
198static SV *sv_activity; 209static SV *sv_activity;
210
211/* enable processtime/realtime profiling */
212static char enable_times;
213typedef U32 coro_ts[2];
214static coro_ts time_real, time_cpu;
215static char times_valid;
199 216
200static struct coro_cctx *cctx_first; 217static struct coro_cctx *cctx_first;
201static int cctx_count, cctx_idle; 218static int cctx_count, cctx_idle;
202 219
203enum { 220enum {
… …
293 310
294 /* on_enter/on_leave */ 311 /* on_enter/on_leave */
295 AV *on_enter; 312 AV *on_enter;
296 AV *on_leave; 313 AV *on_leave;
297 314
315 /* times */
316 coro_ts t_cpu, t_real;
317
298 /* linked list */ 318 /* linked list */
299 struct coro *next, *prev; 319 struct coro *next, *prev;
300}; 320};
301 321
302typedef struct coro *Coro__State; 322typedef struct coro *Coro__State;
… …
307/* the mainr easonw e don't support windows process emulation */ 327/* the mainr easonw e don't support windows process emulation */
308static struct CoroSLF slf_frame; /* the current slf frame */ 328static struct CoroSLF slf_frame; /* the current slf frame */
309 329
310/** Coro ********************************************************************/ 330/** Coro ********************************************************************/
311 331
312#define PRIO_MAX 3 332#define CORO_PRIO_MAX 3
313#define PRIO_HIGH 1 333#define CORO_PRIO_HIGH 1
314#define PRIO_NORMAL 0 334#define CORO_PRIO_NORMAL 0
315#define PRIO_LOW -1 335#define CORO_PRIO_LOW -1
316#define PRIO_IDLE -3 336#define CORO_PRIO_IDLE -3
317#define PRIO_MIN -4 337#define CORO_PRIO_MIN -4
318 338
319/* for Coro.pm */ 339/* for Coro.pm */
320static SV *coro_current; 340static SV *coro_current;
321static SV *coro_readyhook; 341static SV *coro_readyhook;
322static struct coro *coro_ready [PRIO_MAX - PRIO_MIN + 1][2]; /* head|tail */ 342static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */
323static CV *cv_coro_run, *cv_coro_terminate; 343static CV *cv_coro_run, *cv_coro_terminate;
324static struct coro *coro_first; 344static struct coro *coro_first;
325#define coro_nready coroapi.nready 345#define coro_nready coroapi.nready
326 346
327/** lowlevel stuff **********************************************************/ 347/** lowlevel stuff **********************************************************/
… …
366 386
367 if (!cv) 387 if (!cv)
368 croak ("code reference expected"); 388 croak ("code reference expected");
369 389
370 return cv; 390 return cv;
391}
392
393INLINE void
394coro_times_update ()
395{
396#ifdef coro_clock_gettime
397 struct timespec ts;
398
399 ts.tv_sec = ts.tv_nsec = 0;
400 coro_clock_gettime (CORO_CLOCK_THREAD_CPUTIME_ID, &ts);
401 time_cpu [0] = ts.tv_sec; time_cpu [1] = ts.tv_nsec;
402
403 ts.tv_sec = ts.tv_nsec = 0;
404 coro_clock_gettime (CORO_CLOCK_MONOTONIC, &ts);
405 time_real [0] = ts.tv_sec; time_real [1] = ts.tv_nsec;
406#else
407 UV tv[2];
408
409 u2time (aTHX_ &tv);
410 time_real [0] = tv [0];
411 time_real [1] = tv [1] * 1000;
412#endif
413}
414
415INLINE void
416coro_times_add (struct coro *c)
417{
418 c->t_real [1] += time_real [1];
419 if (c->t_real [1] > 1000000000) { c->t_real [1] -= 1000000000; ++c->t_real [0]; }
420 c->t_real [0] += time_real [0];
421
422 c->t_cpu [1] += time_cpu [1];
423 if (c->t_cpu [1] > 1000000000) { c->t_cpu [1] -= 1000000000; ++c->t_cpu [0]; }
424 c->t_cpu [0] += time_cpu [0];
425}
426
427INLINE void
428coro_times_sub (struct coro *c)
429{
430 if (c->t_real [1] < time_real [1]) { c->t_real [1] += 1000000000; --c->t_real [0]; }
431 c->t_real [1] -= time_real [1];
432 c->t_real [0] -= time_real [0];
433
434 if (c->t_cpu [1] < time_cpu [1]) { c->t_cpu [1] += 1000000000; --c->t_cpu [0]; }
435 c->t_cpu [1] -= time_cpu [1];
436 c->t_cpu [0] -= time_cpu [0];
371} 437}
372 438
373/*****************************************************************************/ 439/*****************************************************************************/
374/* magic glue */ 440/* magic glue */
375 441
… …
475static int 541static int
476coro_cv_free (pTHX_ SV *sv, MAGIC *mg) 542coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
477{ 543{
478 AV *padlist; 544 AV *padlist;
479 AV *av = (AV *)mg->mg_obj; 545 AV *av = (AV *)mg->mg_obj;
546
547 /* perl manages to free our internal AV and _then_ call us */
548 if (IN_DESTRUCT)
549 return;
480 550
481 /* casting is fun. */ 551 /* casting is fun. */
482 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av))) 552 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
483 free_padlist (aTHX_ padlist); 553 free_padlist (aTHX_ padlist);
484 554
… …
573 } 643 }
574 644
575 slf_frame = c->slf_frame; 645 slf_frame = c->slf_frame;
576 CORO_THROW = c->except; 646 CORO_THROW = c->except;
577 647
648 if (expect_false (enable_times))
649 {
650 if (expect_false (!times_valid))
651 coro_times_update ();
652
653 coro_times_sub (c);
654 }
655
578 if (expect_false (c->on_enter)) 656 if (expect_false (c->on_enter))
579 { 657 {
580 int i; 658 int i;
581 659
582 for (i = 0; i <= AvFILLp (c->on_enter); ++i) 660 for (i = 0; i <= AvFILLp (c->on_enter); ++i)
… …
591 { 669 {
592 int i; 670 int i;
593 671
594 for (i = AvFILLp (c->on_leave); i >= 0; --i) 672 for (i = AvFILLp (c->on_leave); i >= 0; --i)
595 on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]); 673 on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);
674 }
675
676 times_valid = 0;
677
678 if (expect_false (enable_times))
679 {
680 coro_times_update (); times_valid = 1;
681 coro_times_add (c);
596 } 682 }
597 683
598 c->except = CORO_THROW; 684 c->except = CORO_THROW;
599 c->slf_frame = slf_frame; 685 c->slf_frame = slf_frame;
600 686
… …
615 { 701 {
616 while (expect_true (cxix >= 0)) 702 while (expect_true (cxix >= 0))
617 { 703 {
618 PERL_CONTEXT *cx = &ccstk[cxix--]; 704 PERL_CONTEXT *cx = &ccstk[cxix--];
619 705
620 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT)) 706 if (expect_true (CxTYPE (cx) == CXt_SUB) || expect_false (CxTYPE (cx) == CXt_FORMAT))
621 { 707 {
622 CV *cv = cx->blk_sub.cv; 708 CV *cv = cx->blk_sub.cv;
623 709
624 if (expect_true (CvDEPTH (cv))) 710 if (expect_true (CvDEPTH (cv)))
625 { 711 {
… …
964 1050
965 PL_op = (OP *)&coro_setup_op; 1051 PL_op = (OP *)&coro_setup_op;
966 1052
967 /* copy throw, in case it was set before coro_setup */ 1053 /* copy throw, in case it was set before coro_setup */
968 CORO_THROW = coro->except; 1054 CORO_THROW = coro->except;
1055
1056 if (expect_false (enable_times))
1057 {
1058 coro_times_update ();
1059 coro_times_sub (coro);
1060 }
969} 1061}
970 1062
971static void 1063static void
972coro_unwind_stacks (pTHX) 1064coro_unwind_stacks (pTHX)
973{ 1065{
… …
1622/** Coro ********************************************************************/ 1714/** Coro ********************************************************************/
1623 1715
1624INLINE void 1716INLINE void
1625coro_enq (pTHX_ struct coro *coro) 1717coro_enq (pTHX_ struct coro *coro)
1626{ 1718{
1627 struct coro **ready = coro_ready [coro->prio - PRIO_MIN]; 1719 struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1628 1720
1629 SvREFCNT_inc_NN (coro->hv); 1721 SvREFCNT_inc_NN (coro->hv);
1630 1722
1631 coro->next_ready = 0; 1723 coro->next_ready = 0;
1632 *(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro; 1724 *(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
… …
1636INLINE struct coro * 1728INLINE struct coro *
1637coro_deq (pTHX) 1729coro_deq (pTHX)
1638{ 1730{
1639 int prio; 1731 int prio;
1640 1732
1641 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= 0; ) 1733 for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
1642 { 1734 {
1643 struct coro **ready = coro_ready [prio]; 1735 struct coro **ready = coro_ready [prio];
1644 1736
1645 if (ready [0]) 1737 if (ready [0])
1646 { 1738 {
… …
2477/* Coro::Semaphore & Coro::Signal */ 2569/* Coro::Semaphore & Coro::Signal */
2478 2570
2479static SV * 2571static SV *
2480coro_waitarray_new (pTHX_ int count) 2572coro_waitarray_new (pTHX_ int count)
2481{ 2573{
2482 /* a semaphore contains a counter IV in $sem->[0] and any waiters after that */ 2574 /* a waitarray=semaphore contains a counter IV in $sem->[0] and any waiters after that */
2483 AV *av = newAV (); 2575 AV *av = newAV ();
2484 SV **ary; 2576 SV **ary;
2485 2577
2486 /* unfortunately, building manually saves memory */ 2578 /* unfortunately, building manually saves memory */
2487 Newx (ary, 2, SV *); 2579 Newx (ary, 2, SV *);
… …
2631 { 2723 {
2632 /* callback form */ 2724 /* callback form */
2633 AV *av = (AV *)SvRV (arg [0]); 2725 AV *av = (AV *)SvRV (arg [0]);
2634 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]); 2726 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2635 2727
2636 av_push (av, (SV *)SvREFCNT_inc_NN (cb_cv)); 2728 av_push (av, SvREFCNT_inc_NN (cb_cv));
2637 2729
2638 if (SvIVX (AvARRAY (av)[0]) > 0) 2730 if (SvIVX (AvARRAY (av)[0]) > 0)
2639 coro_semaphore_adjust (aTHX_ av, 0); 2731 coro_semaphore_adjust (aTHX_ av, 0);
2640 2732
2641 frame->prepare = prepare_nop; 2733 frame->prepare = prepare_nop;
… …
2665 AvARRAY (av)[0] = AvARRAY (av)[1]; 2757 AvARRAY (av)[0] = AvARRAY (av)[1];
2666 AvARRAY (av)[1] = cb; 2758 AvARRAY (av)[1] = cb;
2667 2759
2668 cb = av_shift (av); 2760 cb = av_shift (av);
2669 2761
2762 if (SvTYPE (cb) == SVt_PVCV)
2763 {
2764 dSP;
2765 PUSHMARK (SP);
2766 XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
2767 PUTBACK;
2768 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
2769 }
2770 else
2771 {
2670 api_ready (aTHX_ cb); 2772 api_ready (aTHX_ cb);
2671 sv_setiv (cb, 0); /* signal waiter */ 2773 sv_setiv (cb, 0); /* signal waiter */
2774 }
2775
2672 SvREFCNT_dec (cb); 2776 SvREFCNT_dec (cb);
2673 2777
2674 --count; 2778 --count;
2675 } 2779 }
2676} 2780}
… …
2685static void 2789static void
2686slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2790slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2687{ 2791{
2688 AV *av = (AV *)SvRV (arg [0]); 2792 AV *av = (AV *)SvRV (arg [0]);
2689 2793
2794 if (items >= 2)
2795 {
2796 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2797 av_push (av, SvREFCNT_inc_NN (cb_cv));
2798
2690 if (SvIVX (AvARRAY (av)[0])) 2799 if (SvIVX (AvARRAY (av)[0]))
2800 coro_signal_wake (aTHX_ av, 1); /* ust be the only waiter */
2801
2802 frame->prepare = prepare_nop;
2803 frame->check = slf_check_nop;
2804 }
2805 else if (SvIVX (AvARRAY (av)[0]))
2691 { 2806 {
2692 SvIVX (AvARRAY (av)[0]) = 0; 2807 SvIVX (AvARRAY (av)[0]) = 0;
2693 frame->prepare = prepare_nop; 2808 frame->prepare = prepare_nop;
2694 frame->check = slf_check_nop; 2809 frame->check = slf_check_nop;
2695 } 2810 }
2696 else 2811 else
2697 { 2812 {
2698 SV *waiter = newRV_inc (SvRV (coro_current)); /* owned by signal av */ 2813 SV *waiter = newSVsv (coro_current); /* owned by signal av */
2699 2814
2700 av_push (av, waiter); 2815 av_push (av, waiter);
2701 2816
2702 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */ 2817 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */
2703 frame->prepare = prepare_schedule; 2818 frame->prepare = prepare_schedule;
… …
2942 3057
2943 if (!svp) croak ("Time::HiRes is required"); 3058 if (!svp) croak ("Time::HiRes is required");
2944 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer"); 3059 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2945 3060
2946 nvtime = INT2PTR (double (*)(), SvIV (*svp)); 3061 nvtime = INT2PTR (double (*)(), SvIV (*svp));
3062
3063 svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);
3064 u2time = INT2PTR (double (*)(), SvIV (*svp));
2947 } 3065 }
2948 3066
2949 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL)); 3067 assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
2950} 3068}
2951 3069
2952SV * 3070SV *
2953new (char *klass, ...) 3071new (char *klass, ...)
2954 ALIAS: 3072 ALIAS:
… …
3156 CODE: 3274 CODE:
3157{ 3275{
3158 struct coro *current = SvSTATE_current; 3276 struct coro *current = SvSTATE_current;
3159 SV **throwp = self == current ? &CORO_THROW : &self->except; 3277 SV **throwp = self == current ? &CORO_THROW : &self->except;
3160 SvREFCNT_dec (*throwp); 3278 SvREFCNT_dec (*throwp);
3279 SvGETMAGIC (throw);
3161 *throwp = SvOK (throw) ? newSVsv (throw) : 0; 3280 *throwp = SvOK (throw) ? newSVsv (throw) : 0;
3162} 3281}
3163 3282
3164void 3283void
3165api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB) 3284api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
… …
3224 CODE: 3343 CODE:
3225 coro_state_destroy (aTHX_ self); 3344 coro_state_destroy (aTHX_ self);
3226 coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */ 3345 coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3227 3346
3228 3347
3348SV *
3349enable_times (int enabled = enable_times)
3350 CODE:
3351{
3352 RETVAL = boolSV (enable_times);
3353
3354 if (enabled != enable_times)
3355 {
3356 enable_times = enabled;
3357
3358 coro_times_update ();
3359 (enabled ? coro_times_sub : coro_times_add)(SvSTATE (coro_current));
3360 }
3361}
3362 OUTPUT:
3363 RETVAL
3364
3365void
3366times (Coro::State self)
3367 PPCODE:
3368{
3369 struct coro *current = SvSTATE (coro_current);
3370
3371 if (expect_false (current == self))
3372 {
3373 coro_times_update ();
3374 coro_times_add (SvSTATE (coro_current));
3375 }
3376
3377 EXTEND (SP, 2);
3378 PUSHs (sv_2mortal (newSVnv (self->t_real [0] + self->t_real [1] * 1e-9)));
3379 PUSHs (sv_2mortal (newSVnv (self->t_cpu [0] + self->t_cpu [1] * 1e-9)));
3380
3381 if (expect_false (current == self))
3382 coro_times_sub (SvSTATE (coro_current));
3383}
3384
3229MODULE = Coro::State PACKAGE = Coro 3385MODULE = Coro::State PACKAGE = Coro
3230 3386
3231BOOT: 3387BOOT:
3232{ 3388{
3233 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE); 3389 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
… …
3245 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler); 3401 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler);
3246 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new); 3402 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new);
3247 3403
3248 coro_stash = gv_stashpv ("Coro", TRUE); 3404 coro_stash = gv_stashpv ("Coro", TRUE);
3249 3405
3250 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX)); 3406 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (CORO_PRIO_MAX));
3251 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH)); 3407 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (CORO_PRIO_HIGH));
3252 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL)); 3408 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (CORO_PRIO_NORMAL));
3253 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW)); 3409 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (CORO_PRIO_LOW));
3254 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE)); 3410 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (CORO_PRIO_IDLE));
3255 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN)); 3411 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (CORO_PRIO_MIN));
3256 3412
3257 { 3413 {
3258 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE); 3414 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
3259 3415
3260 coroapi.schedule = api_schedule; 3416 coroapi.schedule = api_schedule;
… …
3312void 3468void
3313_set_readyhook (SV *hook) 3469_set_readyhook (SV *hook)
3314 PROTOTYPE: $ 3470 PROTOTYPE: $
3315 CODE: 3471 CODE:
3316 SvREFCNT_dec (coro_readyhook); 3472 SvREFCNT_dec (coro_readyhook);
3473 SvGETMAGIC (hook);
3317 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0; 3474 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
3318 3475
3319int 3476int
3320prio (Coro::State coro, int newprio = 0) 3477prio (Coro::State coro, int newprio = 0)
3321 PROTOTYPE: $;$ 3478 PROTOTYPE: $;$
… …
3328 if (items > 1) 3485 if (items > 1)
3329 { 3486 {
3330 if (ix) 3487 if (ix)
3331 newprio = coro->prio - newprio; 3488 newprio = coro->prio - newprio;
3332 3489
3333 if (newprio < PRIO_MIN) newprio = PRIO_MIN; 3490 if (newprio < CORO_PRIO_MIN) newprio = CORO_PRIO_MIN;
3334 if (newprio > PRIO_MAX) newprio = PRIO_MAX; 3491 if (newprio > CORO_PRIO_MAX) newprio = CORO_PRIO_MAX;
3335 3492
3336 coro->prio = newprio; 3493 coro->prio = newprio;
3337 } 3494 }
3338} 3495}
3339 OUTPUT: 3496 OUTPUT:
… …
3465MODULE = Coro::State PACKAGE = Coro::Semaphore 3622MODULE = Coro::State PACKAGE = Coro::Semaphore
3466 3623
3467SV * 3624SV *
3468new (SV *klass, SV *count = 0) 3625new (SV *klass, SV *count = 0)
3469 CODE: 3626 CODE:
3627{
3628 int semcnt = 1;
3629
3630 if (count)
3631 {
3632 SvGETMAGIC (count);
3633
3634 if (SvOK (count))
3635 semcnt = SvIV (count);
3636 }
3637
3470 RETVAL = sv_bless ( 3638 RETVAL = sv_bless (
3471 coro_waitarray_new (aTHX_ count && SvOK (count) ? SvIV (count) : 1), 3639 coro_waitarray_new (aTHX_ semcnt),
3472 GvSTASH (CvGV (cv)) 3640 GvSTASH (CvGV (cv))
3473 ); 3641 );
3642}
3474 OUTPUT: 3643 OUTPUT:
3475 RETVAL 3644 RETVAL
3476 3645
3477# helper for Coro::Channel and others 3646# helper for Coro::Channel and others
3478SV * 3647SV *

Diff Legend

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