Coro/Event/Event.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <string.h>

/* this useful idiom is unfortunately missing... */
static void
confess (const char *msg)
{
  dSP;

  PUSHMARK(SP);
  XPUSHs (sv_2mortal(newSVpv("only one coroutine can wait for an event",0)));
  PUTBACK;
  call_pv ("Carp::confess", G_VOID);
}

#include "EventAPI.h"
#include "../Coro/CoroAPI.h"

#define CD_CORO 0
#define CD_TYPE 1
#define CD_OK   2
#define CD_PRIO 3 /* hardcoded in Coro::Event */
#define CD_HITS 4 /* hardcoded in Coro::Event */
#define CD_GOT  5 /* hardcoded in Coro::Event, Coro::Handle */
#define CD_MAX  5

#define EV_CLASS "Coro::Event"

static pe_idle *scheduler;
static int do_schedule;

#define NEED_SCHEDULE if (!do_schedule)                                 \
                        {                                               \
                          do_schedule = 1;                              \
                          GEventAPI->now ((pe_watcher *)scheduler);     \
                        }

static void
coro_std_cb(pe_event *pe)
{
  AV *priv = (AV *)pe->ext_data;
  IV type = SvIV (*av_fetch (priv, CD_TYPE, 1));
  SV **cd_coro = &AvARRAY(priv)[CD_CORO];

  sv_setiv (AvARRAY(priv)[CD_PRIO], pe->prio);
  sv_setiv (AvARRAY(priv)[CD_HITS], pe->hits);

  if (type == 1)
    sv_setiv (AvARRAY(priv)[CD_GOT], ((pe_ioevent *)pe)->got);

  if (*cd_coro != &PL_sv_undef)
    {
      CORO_READY (*cd_coro);
      SvREFCNT_dec (*cd_coro);
      *cd_coro = &PL_sv_undef;
      NEED_SCHEDULE;
    }
  else
    {
      AvARRAY(priv)[CD_OK] = &PL_sv_yes;
      GEventAPI->stop (pe->up, 0);
    }
}

static void
scheduler_cb(pe_event *pe)
{
  while (CORO_NREADY)
    CORO_CEDE;

  do_schedule = 0;
}

MODULE = Coro::Event                PACKAGE = Coro::Event

PROTOTYPES: ENABLE

BOOT:
{
        I_EVENT_API("Coro::Event");
        I_CORO_API ("Coro::Event");

        /* create a fake idle handler (we only ever call now) */
        scheduler = GEventAPI->new_idle (0, 0);
        scheduler->base.callback = scheduler_cb;
        scheduler->base.prio = PE_PRIO_NORMAL; /* StarvePrio */
        scheduler->min_interval = newSVnv (0);
        scheduler->max_interval = newSVnv (0);
        GEventAPI->stop ((pe_watcher *)scheduler, 0);
}

void
_install_std_cb(self,type)
        SV *    self
        int     type
        CODE:
        pe_watcher *w = GEventAPI->sv_2watcher (self);
        AV *priv = newAV ();
        SV *rv = newRV_noinc ((SV *)priv);

        av_extend (priv, CD_MAX);
        av_store (priv, CD_CORO, &PL_sv_undef);
        av_store (priv, CD_TYPE, newSViv (type));
        av_store (priv, CD_OK  , &PL_sv_no);
        av_store (priv, CD_PRIO, newSViv (0));
        av_store (priv, CD_HITS, newSViv (0));
        av_store (priv, CD_GOT , type ? newSViv (0) : &PL_sv_undef);
        SvREADONLY_on (priv);

        w->callback = coro_std_cb;
        w->ext_data = priv;

        hv_store ((HV *)SvRV (self),
                  EV_CLASS, strlen (EV_CLASS),
                  rv, 0);

        GEventAPI->start (w, 0);

void
_next(self)
        SV *    self
        CODE:
        pe_watcher *w = GEventAPI->sv_2watcher (self);
        AV *priv = (AV *)w->ext_data;

        if (!w->running)
          GEventAPI->start (w, 1);

        if (AvARRAY(priv)[CD_OK] == &PL_sv_yes)
          {
            AvARRAY(priv)[CD_OK] = &PL_sv_no;
            XSRETURN_NO;
          }
        else 
          {
            if (AvARRAY(priv)[CD_CORO] != &PL_sv_undef)
              confess ("only one coroutine can wait for an event");

            AvARRAY(priv)[CD_CORO] = SvREFCNT_inc (CORO_CURRENT);
            XSRETURN_YES;
          }

MODULE = Coro::Event                PACKAGE = Coro

# overwrite the ready function
void
ready(self)
        SV *    self
        PROTOTYPE: $
        CODE:
        NEED_SCHEDULE;
        CORO_READY (self);


Revision:	1.8
Committed:	Sun Apr 14 01:18:38 2002 UTC (22 years, 2 months ago) by root
Branch:	MAIN
Changes since 1.7:	+2 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "EXTERN.h"
2			#include "perl.h"
3			#include "XSUB.h"
4
5	root	1.3	#include <string.h>
6
7	root	1.6	/* this useful idiom is unfortunately missing... */
8			static void
9			confess (const char *msg)
10			{
11			dSP;
12
13			PUSHMARK(SP);
14			XPUSHs (sv_2mortal(newSVpv("only one coroutine can wait for an event",0)));
15			PUTBACK;
16			call_pv ("Carp::confess", G_VOID);
17			}
18
19	root	1.2	#include "EventAPI.h"
20			#include "../Coro/CoroAPI.h"
21	root	1.1
22	root	1.3	#define CD_CORO 0
23			#define CD_TYPE 1
24	root	1.4	#define CD_OK 2
25	root	1.6	#define CD_PRIO 3 /* hardcoded in Coro::Event */
26			#define CD_HITS 4 /* hardcoded in Coro::Event */
27			#define CD_GOT 5 /* hardcoded in Coro::Event, Coro::Handle */
28			#define CD_MAX 5
29	root	1.3
30	root	1.4	#define EV_CLASS "Coro::Event"
31	root	1.3
32			static pe_idle *scheduler;
33			static int do_schedule;
34
35			#define NEED_SCHEDULE if (!do_schedule) \
36			{ \
37			do_schedule = 1; \
38			GEventAPI->now ((pe_watcher *)scheduler); \
39			}
40	root	1.4
41	root	1.3	static void
42			coro_std_cb(pe_event *pe)
43			{
44	root	1.6	AV priv = (AV )pe->ext_data;
45	root	1.4	IV type = SvIV (*av_fetch (priv, CD_TYPE, 1));
46	root	1.6	SV **cd_coro = &AvARRAY(priv)[CD_CORO];
47
48			sv_setiv (AvARRAY(priv)[CD_PRIO], pe->prio);
49			sv_setiv (AvARRAY(priv)[CD_HITS], pe->hits);
50	root	1.3
51			if (type == 1)
52	root	1.6	sv_setiv (AvARRAY(priv)[CD_GOT], ((pe_ioevent *)pe)->got);
53	root	1.3
54	root	1.6	if (*cd_coro != &PL_sv_undef)
55	root	1.3	{
56	root	1.6	CORO_READY (*cd_coro);
57			SvREFCNT_dec (*cd_coro);
58			*cd_coro = &PL_sv_undef;
59	root	1.3	NEED_SCHEDULE;
60			}
61	root	1.4	else
62			{
63	root	1.6	AvARRAY(priv)[CD_OK] = &PL_sv_yes;
64	root	1.4	GEventAPI->stop (pe->up, 0);
65			}
66	root	1.3	}
67
68			static void
69			scheduler_cb(pe_event *pe)
70			{
71			while (CORO_NREADY)
72			CORO_CEDE;
73
74			do_schedule = 0;
75			}
76
77	root	1.1	MODULE = Coro::Event PACKAGE = Coro::Event
78
79	root	1.3	PROTOTYPES: ENABLE
80
81	root	1.1	BOOT:
82			{
83			I_EVENT_API("Coro::Event");
84			I_CORO_API ("Coro::Event");
85	root	1.3
86			/* create a fake idle handler (we only ever call now) */
87			scheduler = GEventAPI->new_idle (0, 0);
88			scheduler->base.callback = scheduler_cb;
89	root	1.6	scheduler->base.prio = PE_PRIO_NORMAL; /* StarvePrio */
90	root	1.3	scheduler->min_interval = newSVnv (0);
91			scheduler->max_interval = newSVnv (0);
92			GEventAPI->stop ((pe_watcher *)scheduler, 0);
93	root	1.1	}
94	root	1.3
95			void
96			_install_std_cb(self,type)
97			SV * self
98			int type
99			CODE:
100			pe_watcher *w = GEventAPI->sv_2watcher (self);
101			AV *priv = newAV ();
102	root	1.4	SV rv = newRV_noinc ((SV )priv);
103	root	1.3
104			av_extend (priv, CD_MAX);
105	root	1.6	av_store (priv, CD_CORO, &PL_sv_undef);
106	root	1.3	av_store (priv, CD_TYPE, newSViv (type));
107	root	1.6	av_store (priv, CD_OK , &PL_sv_no);
108			av_store (priv, CD_PRIO, newSViv (0));
109			av_store (priv, CD_HITS, newSViv (0));
110			av_store (priv, CD_GOT , type ? newSViv (0) : &PL_sv_undef);
111			SvREADONLY_on (priv);
112	root	1.3
113	root	1.4	w->callback = coro_std_cb;
114	root	1.6	w->ext_data = priv;
115	root	1.3
116			hv_store ((HV *)SvRV (self),
117			EV_CLASS, strlen (EV_CLASS),
118			rv, 0);
119
120	root	1.8	GEventAPI->start (w, 0);
121
122	root	1.3	void
123	root	1.4	_next(self)
124	root	1.3	SV * self
125			CODE:
126			pe_watcher *w = GEventAPI->sv_2watcher (self);
127	root	1.6	AV priv = (AV )w->ext_data;
128	root	1.3
129	root	1.4	if (!w->running)
130			GEventAPI->start (w, 1);
131	root	1.3
132	root	1.6	if (AvARRAY(priv)[CD_OK] == &PL_sv_yes)
133	root	1.4	{
134	root	1.6	AvARRAY(priv)[CD_OK] = &PL_sv_no;
135	root	1.4	XSRETURN_NO;
136			}
137			else
138			{
139	root	1.6	if (AvARRAY(priv)[CD_CORO] != &PL_sv_undef)
140			confess ("only one coroutine can wait for an event");
141
142			AvARRAY(priv)[CD_CORO] = SvREFCNT_inc (CORO_CURRENT);
143	root	1.4	XSRETURN_YES;
144			}
145	root	1.6
146			MODULE = Coro::Event PACKAGE = Coro
147
148			# overwrite the ready function
149			void
150			ready(self)
151			SV * self
152	root	1.7	PROTOTYPE: $
153	root	1.6	CODE:
154			NEED_SCHEDULE;
155			CORO_READY (self);
156
157	root	1.3