[ViewVC] Diff of: cvs/IO-AIO/AIO.xs

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.3 by root, Sun Jul 10 20:07:11 2005 UTC vs.
Revision 1.17 by root, Sun Jul 31 18:45:48 2005 UTC

…		…
1	#define PERL_NO_GET_CONTEXT
2
3	#include "EXTERN.h"	1	#include "EXTERN.h"
4	#include "perl.h"	2	#include "perl.h"
5	#include "XSUB.h"	3	#include "XSUB.h"
6		4
		5	#include "autoconf/config.h"
		6
7	#include <sys/types.h>	7	#include <sys/types.h>
8	#include <sys/stat.h>	8	#include <sys/stat.h>
		9
9	#include <unistd.h>	10	#include <unistd.h>
10	#include <fcntl.h>	11	#include <fcntl.h>
11	#include <signal.h>	12	#include <signal.h>
12	#include <sched.h>	13	#include <sched.h>
13	#include <endian.h>
14		14
15	#include <pthread.h>	15	#include <pthread.h>
16	#include <sys/syscall.h>
17		16
18	typedef void InputStream; / hack, but 5.6.1 is simply toooo old ;) */	17	typedef void InputStream; / hack, but 5.6.1 is simply toooo old ;) */
19	typedef void OutputStream; / hack, but 5.6.1 is simply toooo old ;) */	18	typedef void OutputStream; / hack, but 5.6.1 is simply toooo old ;) */
20	typedef void InOutStream; / hack, but 5.6.1 is simply toooo old ;) */	19	typedef void InOutStream; / hack, but 5.6.1 is simply toooo old ;) */
21		20
22	#if __i386 \|\| __amd64
23	# define STACKSIZE ( 256 * sizeof (long))
24	#elif __ia64	21	#if __ia64
25	# define STACKSIZE (8192 * sizeof (long))	22	# define STACKSIZE 65536
26	#else	23	#else
27	# define STACKSIZE ( 512 * sizeof (long))	24	# define STACKSIZE 4096
28	#endif	25	#endif
29		26
30	enum {	27	enum {
31	REQ_QUIT,	28	REQ_QUIT,
32	REQ_OPEN, REQ_CLOSE,	29	REQ_OPEN, REQ_CLOSE,
44	off_t offset;	41	off_t offset;
45	size_t length;	42	size_t length;
46	ssize_t result;	43	ssize_t result;
47	mode_t mode; /* open */	44	mode_t mode; /* open */
48	int errorno;	45	int errorno;
49	SV data, callback;	46	SV data, callback, *fh;
50	void *dataptr;	47	void *dataptr;
51	STRLEN dataoffset;	48	STRLEN dataoffset;
52		49
53	Stat_t *statdata;	50	Stat_t *statdata;
54	} aio_cb;	51	} aio_cb;
55		52
56	typedef aio_cb *aio_req;	53	typedef aio_cb *aio_req;
57		54
58	static int started;	55	static int started;
59	static int nreqs;	56	static volatile int nreqs;
		57	static int max_outstanding = 1<<30;
60	static int respipe [2];	58	static int respipe [2];
61		59
62	static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER;	60	static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER;
63	static pthread_mutex_t reqlock = PTHREAD_MUTEX_INITIALIZER;	61	static pthread_mutex_t reqlock = PTHREAD_MUTEX_INITIALIZER;
64	static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;	62	static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
65		63
66	static volatile aio_req reqs, reqe; /* queue start, queue end */	64	static volatile aio_req reqs, reqe; /* queue start, queue end */
67	static volatile aio_req ress, rese; /* queue start, queue end */	65	static volatile aio_req ress, rese; /* queue start, queue end */
		66
		67	static void
		68	poll_wait ()
		69	{
		70	if (nreqs && !ress)
		71	{
		72	fd_set rfd;
		73	FD_ZERO(&rfd);
		74	FD_SET(respipe [0], &rfd);
		75
		76	select (respipe [0] + 1, &rfd, 0, 0, 0);
		77	}
		78	}
		79
		80	static int
		81	poll_cb ()
		82	{
		83	dSP;
		84	int count = 0;
		85	aio_req req, prv;
		86
		87	pthread_mutex_lock (&reslock);
		88
		89	{
		90	/* read any signals sent by the worker threads */
		91	char buf [32];
		92	while (read (respipe [0], buf, 32) > 0)
		93	;
		94	}
		95
		96	req = ress;
		97	ress = rese = 0;
		98
		99	pthread_mutex_unlock (&reslock);
		100
		101	while (req)
		102	{
		103	nreqs--;
		104
		105	if (req->type == REQ_QUIT)
		106	started--;
		107	else
		108	{
		109	int errorno = errno;
		110	errno = req->errorno;
		111
		112	if (req->type == REQ_READ)
		113	SvCUR_set (req->data, req->dataoffset
		114	+ req->result > 0 ? req->result : 0);
		115
		116	if (req->data)
		117	SvREFCNT_dec (req->data);
		118
		119	if (req->fh)
		120	SvREFCNT_dec (req->fh);
		121
		122	if (req->type == REQ_STAT \|\| req->type == REQ_LSTAT \|\| req->type == REQ_FSTAT)
		123	{
		124	PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
		125	PL_laststatval = req->result;
		126	PL_statcache = *(req->statdata);
		127
		128	Safefree (req->statdata);
		129	}
		130
		131	ENTER;
		132	PUSHMARK (SP);
		133	XPUSHs (sv_2mortal (newSViv (req->result)));
		134
		135	if (req->type == REQ_OPEN)
		136	{
		137	/* convert fd to fh */
		138	SV *fh;
		139
		140	PUTBACK;
		141	call_pv ("IO::AIO::_fd2fh", G_SCALAR \| G_EVAL);
		142	SPAGAIN;
		143
		144	fh = SvREFCNT_inc (POPs);
		145
		146	PUSHMARK (SP);
		147	XPUSHs (sv_2mortal (fh));
		148	}
		149
		150	if (SvOK (req->callback))
		151	{
		152	PUTBACK;
		153	call_sv (req->callback, G_VOID \| G_EVAL);
		154	SPAGAIN;
		155	}
		156
		157	LEAVE;
		158
		159	if (req->callback)
		160	SvREFCNT_dec (req->callback);
		161
		162	errno = errorno;
		163	count++;
		164	}
		165
		166	prv = req;
		167	req = req->next;
		168	Safefree (prv);
		169
		170	/* TODO: croak on errors? */
		171	}
		172
		173	return count;
		174	}
68		175
69	static void aio_proc(void arg);	176	static void aio_proc(void arg);
70		177
71	static void	178	static void
72	start_thread (void)	179	start_thread (void)
…		…
105	else	212	else
106	reqe = reqs = req;	213	reqe = reqs = req;
107		214
108	pthread_cond_signal (&reqwait);	215	pthread_cond_signal (&reqwait);
109	pthread_mutex_unlock (&reqlock);	216	pthread_mutex_unlock (&reqlock);
		217
		218	while (nreqs > max_outstanding)
		219	{
		220	poll_wait ();
		221	poll_cb ();
		222	}
110	}	223	}
111		224
112	static void	225	static void
113	end_thread (void)	226	end_thread (void)
114	{	227	{
…		…
117	req->type = REQ_QUIT;	230	req->type = REQ_QUIT;
118		231
119	send_req (req);	232	send_req (req);
120	}	233	}
121		234
122	static void	235	/* work around various missing functions */
123	read_write (pTHX_
124	int dowrite, int fd, off_t offset, size_t length,
125	SV data, STRLEN dataoffset, SV callback)
126	{
127	aio_req req;
128	STRLEN svlen;
129	char *svptr = SvPV (data, svlen);
130		236
131	SvUPGRADE (data, SVt_PV);	237	#if !HAVE_PREADWRITE
132	SvPOK_on (data);	238	# define pread aio_pread
		239	# define pwrite aio_pwrite
133		240
134	if (dataoffset < 0)	241	/*
135	dataoffset += svlen;	242	* make our pread/pwrite safe against themselves, but not against
		243	* normal read/write by using a mutex. slows down execution a lot,
		244	* but that's your problem, not mine.
		245	*/
		246	static pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER;
136		247
137	if (dataoffset < 0 \|\| dataoffset > svlen)	248	static ssize_t
138	croak ("data offset outside of string");	249	pread (int fd, void *buf, size_t count, off_t offset)
		250	{
		251	ssize_t res;
		252	off_t ooffset;
139		253
140	if (dowrite)	254	pthread_mutex_lock (&iolock);
		255	ooffset = lseek (fd, 0, SEEK_CUR);
		256	lseek (fd, offset, SEEK_SET);
		257	res = read (fd, buf, count);
		258	lseek (fd, ooffset, SEEK_SET);
		259	pthread_mutex_unlock (&iolock);
		260
		261	return res;
		262	}
		263
		264	static ssize_t
		265	pwrite (int fd, void *buf, size_t count, off_t offset)
		266	{
		267	ssize_t res;
		268	off_t ooffset;
		269
		270	pthread_mutex_lock (&iolock);
		271	ooffset = lseek (fd, 0, SEEK_CUR);
		272	lseek (fd, offset, SEEK_SET);
		273	res = write (fd, buf, count);
		274	lseek (fd, offset, SEEK_SET);
		275	pthread_mutex_unlock (&iolock);
		276
		277	return res;
		278	}
		279	#endif
		280
		281	#if !HAVE_FDATASYNC
		282	# define fdatasync fsync
		283	#endif
		284
		285	#if !HAVE_READAHEAD
		286	# define readahead aio_readahead
		287
		288	static char readahead_buf[4096];
		289
		290	static ssize_t
		291	readahead (int fd, off_t offset, size_t count)
		292	{
		293	while (count > 0)
141	{	294	{
142	/* write: check length and adjust. */	295	size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
143	if (length < 0 \|\| length + dataoffset > svlen)	296
144	length = svlen - dataoffset;	297	pread (fd, readahead_buf, len, offset);
		298	offset += len;
		299	count -= len;
145	}	300	}
146	else
147	{
148	/* read: grow scalar as necessary */
149	svptr = SvGROW (data, length + dataoffset);
150	}
151		301
152	if (length < 0)	302	errno = 0;
153	croak ("length must not be negative");
154
155	Newz (0, req, 1, aio_cb);
156
157	if (!req)
158	croak ("out of memory during aio_req allocation");
159
160	req->type = dowrite ? REQ_WRITE : REQ_READ;
161	req->fd = fd;
162	req->offset = offset;
163	req->length = length;
164	req->data = SvREFCNT_inc (data);
165	req->dataptr = (char *)svptr + dataoffset;
166	req->callback = SvREFCNT_inc (callback);
167
168	send_req (req);
169	}	303	}
170		304	#endif
171	static void
172	poll_wait ()
173	{
174	if (!nreqs)
175	return;
176
177	fd_set rfd;
178	FD_ZERO(&rfd);
179	FD_SET(respipe [0], &rfd);
180
181	select (respipe [0] + 1, &rfd, 0, 0, 0);
182	}
183
184	static int
185	poll_cb (pTHX)
186	{
187	dSP;
188	int count = 0;
189	aio_req req;
190
191	{
192	/* read and signals sent by the worker threads */
193	char buf [32];
194	while (read (respipe [0], buf, 32) > 0)
195	;
196	}
197
198	for (;;)
199	{
200	pthread_mutex_lock (&reslock);
201
202	req = ress;
203
204	if (ress)
205	{
206	ress = ress->next;
207	if (!ress) rese = 0;
208	}
209
210	pthread_mutex_unlock (&reslock);
211
212	if (!req)
213	break;
214
215	nreqs--;
216
217	if (req->type == REQ_QUIT)
218	started--;
219	else
220	{
221	int errorno = errno;
222	errno = req->errorno;
223
224	if (req->type == REQ_READ)
225	SvCUR_set (req->data, req->dataoffset
226	+ req->result > 0 ? req->result : 0);
227
228	if (req->data)
229	SvREFCNT_dec (req->data);
230
231	if (req->type == REQ_STAT \|\| req->type == REQ_LSTAT \|\| req->type == REQ_FSTAT)
232	{
233	PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
234	PL_laststatval = req->result;
235	PL_statcache = *(req->statdata);
236
237	Safefree (req->statdata);
238	}
239
240	PUSHMARK (SP);
241	XPUSHs (sv_2mortal (newSViv (req->result)));
242
243	if (req->type == REQ_OPEN)
244	{
245	/* convert fd to fh */
246	SV *fh;
247
248	PUTBACK;
249	call_pv ("IO::AIO::_fd2fh", G_SCALAR \| G_EVAL);
250	SPAGAIN;
251
252	fh = POPs;
253
254	PUSHMARK (SP);
255	XPUSHs (fh);
256	}
257
258	PUTBACK;
259	call_sv (req->callback, G_VOID \| G_EVAL);
260	SPAGAIN;
261
262	if (req->callback)
263	SvREFCNT_dec (req->callback);
264
265	errno = errorno;
266	count++;
267	}
268
269	Safefree (req);
270	}
271
272	return count;
273	}
274		305
275	static void *	306	static void *
276	aio_proc (void *thr_arg)	307	aio_proc (void *thr_arg)
277	{	308	{
278	aio_req req;	309	aio_req req;
…		…
304		335
305	type = req->type;	336	type = req->type;
306		337
307	switch (type)	338	switch (type)
308	{	339	{
309	case REQ_READ: req->result = pread64 (req->fd, req->dataptr, req->length, req->offset); break;	340	case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
310	case REQ_WRITE: req->result = pwrite64 (req->fd, req->dataptr, req->length, req->offset); break;	341	case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
311	#if SYS_readahead	342
312	case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;	343	case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
313	#else
314	case REQ_READAHEAD: req->result = -1; errno = ENOSYS; break;
315	#endif
316		344
317	case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;	345	case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;
318	case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;	346	case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;
319	case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;	347	case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;
320		348
321	case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break;	349	case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break;
322	case REQ_CLOSE: req->result = close (req->fd); break;	350	case REQ_CLOSE: req->result = close (req->fd); break;
323	case REQ_UNLINK: req->result = unlink (req->dataptr); break;	351	case REQ_UNLINK: req->result = unlink (req->dataptr); break;
324		352
		353	case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
325	case REQ_FSYNC: req->result = fsync (req->fd); break;	354	case REQ_FSYNC: req->result = fsync (req->fd); break;
326	case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
327		355
328	case REQ_QUIT:	356	case REQ_QUIT:
329	break;	357	break;
330		358
331	default:	359	default:
…		…
359	return 0;	387	return 0;
360	}	388	}
361		389
362	MODULE = IO::AIO PACKAGE = IO::AIO	390	MODULE = IO::AIO PACKAGE = IO::AIO
363		391
		392	PROTOTYPES: ENABLE
		393
364	BOOT:	394	BOOT:
365	{	395	{
366	if (pipe (respipe))	396	if (pipe (respipe))
367	croak ("unable to initialize result pipe");	397	croak ("unable to initialize result pipe");
368		398
…		…
395	}	425	}
396		426
397	while (started > nthreads)	427	while (started > nthreads)
398	{	428	{
399	poll_wait ();	429	poll_wait ();
400	poll_cb (aTHX);	430	poll_cb ();
401	}	431	}
402	}	432	}
403		433
		434	int
		435	max_outstanding(nreqs)
		436	int nreqs
		437	PROTOTYPE: $
		438	CODE:
		439	RETVAL = max_outstanding;
		440	max_outstanding = nreqs;
		441
404	void	442	void
405	aio_open(pathname,flags,mode,callback)	443	aio_open(pathname,flags,mode,callback=&PL_sv_undef)
406	SV * pathname	444	SV * pathname
407	int flags	445	int flags
408	int mode	446	int mode
409	SV * callback	447	SV * callback
410	PROTOTYPE: $$$$	448	PROTOTYPE: $$$;$
411	CODE:	449	CODE:
412	{	450	{
413	aio_req req;	451	aio_req req;
414		452
415	Newz (0, req, 1, aio_cb);	453	Newz (0, req, 1, aio_cb);
…		…
426		464
427	send_req (req);	465	send_req (req);
428	}	466	}
429		467
430	void	468	void
431	aio_close(fh,callback)	469	aio_close(fh,callback=&PL_sv_undef)
432	InputStream fh	470	SV * fh
433	SV * callback	471	SV * callback
434	PROTOTYPE: $$	472	PROTOTYPE: $;$
435	ALIAS:	473	ALIAS:
436	aio_close = REQ_CLOSE	474	aio_close = REQ_CLOSE
437	aio_fsync = REQ_FSYNC	475	aio_fsync = REQ_FSYNC
438	aio_fdatasync = REQ_FDATASYNC	476	aio_fdatasync = REQ_FDATASYNC
439	CODE:	477	CODE:
…		…
444		482
445	if (!req)	483	if (!req)
446	croak ("out of memory during aio_req allocation");	484	croak ("out of memory during aio_req allocation");
447		485
448	req->type = ix;	486	req->type = ix;
		487	req->fh = newSVsv (fh);
449	req->fd = PerlIO_fileno (fh);	488	req->fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
450	req->callback = SvREFCNT_inc (callback);	489	req->callback = SvREFCNT_inc (callback);
451		490
452	send_req (req);	491	send_req (req);
453	}	492	}
454		493
455	void	494	void
456	aio_read(fh,offset,length,data,dataoffset,callback)	495	aio_read(fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
457	InputStream fh	496	SV * fh
458	UV offset	497	UV offset
459	IV length	498	IV length
460	SV * data	499	SV * data
461	IV dataoffset	500	IV dataoffset
462	SV * callback	501	SV * callback
		502	ALIAS:
		503	aio_read = REQ_READ
		504	aio_write = REQ_WRITE
463	PROTOTYPE: $$$$$$	505	PROTOTYPE: $$$$$;$
464	CODE:	506	CODE:
465	read_write (aTHX_ 0, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
466
467	void
468	aio_write(fh,offset,length,data,dataoffset,callback)
469	OutputStream fh
470	UV offset
471	IV length
472	SV * data
473	IV dataoffset
474	SV * callback
475	PROTOTYPE: $$$$$$
476	CODE:
477	read_write (aTHX_ 1, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
478
479	void
480	aio_readahead(fh,offset,length,callback)
481	InputStream fh
482	UV offset
483	IV length
484	SV * callback
485	PROTOTYPE: $$$$
486	CODE:
487	{	507	{
488	aio_req req;	508	aio_req req;
		509	STRLEN svlen;
		510	char *svptr = SvPV (data, svlen);
		511
		512	SvUPGRADE (data, SVt_PV);
		513	SvPOK_on (data);
		514
		515	if (dataoffset < 0)
		516	dataoffset += svlen;
		517
		518	if (dataoffset < 0 \|\| dataoffset > svlen)
		519	croak ("data offset outside of string");
		520
		521	if (ix == REQ_WRITE)
		522	{
		523	/* write: check length and adjust. */
		524	if (length < 0 \|\| length + dataoffset > svlen)
		525	length = svlen - dataoffset;
		526	}
		527	else
		528	{
		529	/* read: grow scalar as necessary */
		530	svptr = SvGROW (data, length + dataoffset);
		531	}
489		532
490	if (length < 0)	533	if (length < 0)
491	croak ("length must not be negative");	534	croak ("length must not be negative");
492		535
493	Newz (0, req, 1, aio_cb);	536	Newz (0, req, 1, aio_cb);
494		537
495	if (!req)	538	if (!req)
496	croak ("out of memory during aio_req allocation");	539	croak ("out of memory during aio_req allocation");
497		540
		541	req->type = ix;
		542	req->fh = newSVsv (fh);
		543	req->fd = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh))
		544	: IoOFP (sv_2io (fh)));
		545	req->offset = offset;
		546	req->length = length;
		547	req->data = SvREFCNT_inc (data);
		548	req->dataptr = (char *)svptr + dataoffset;
		549	req->callback = SvREFCNT_inc (callback);
		550
		551	send_req (req);
		552	}
		553
		554	void
		555	aio_readahead(fh,offset,length,callback=&PL_sv_undef)
		556	SV * fh
		557	UV offset
		558	IV length
		559	SV * callback
		560	PROTOTYPE: $$$;$
		561	CODE:
		562	{
		563	aio_req req;
		564
		565	if (length < 0)
		566	croak ("length must not be negative");
		567
		568	Newz (0, req, 1, aio_cb);
		569
		570	if (!req)
		571	croak ("out of memory during aio_req allocation");
		572
498	req->type = REQ_READAHEAD;	573	req->type = REQ_READAHEAD;
		574	req->fh = newSVsv (fh);
499	req->fd = PerlIO_fileno (fh);	575	req->fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
500	req->offset = offset;	576	req->offset = offset;
501	req->length = length;	577	req->length = length;
502	req->callback = SvREFCNT_inc (callback);	578	req->callback = SvREFCNT_inc (callback);
503		579
504	send_req (req);	580	send_req (req);
505	}	581	}
506		582
507	void	583	void
508	aio_stat(fh_or_path,callback)	584	aio_stat(fh_or_path,callback=&PL_sv_undef)
509	SV * fh_or_path	585	SV * fh_or_path
510	SV * callback	586	SV * callback
511	PROTOTYPE: $$
512	ALIAS:	587	ALIAS:
		588	aio_stat = REQ_STAT
513	aio_lstat = 1	589	aio_lstat = REQ_LSTAT
514	CODE:	590	CODE:
515	{	591	{
516	aio_req req;	592	aio_req req;
517		593
518	Newz (0, req, 1, aio_cb);	594	Newz (0, req, 1, aio_cb);
…		…
525	if (!req->statdata)	601	if (!req->statdata)
526	croak ("out of memory during aio_req->statdata allocation");	602	croak ("out of memory during aio_req->statdata allocation");
527		603
528	if (SvPOK (fh_or_path))	604	if (SvPOK (fh_or_path))
529	{	605	{
530	req->type = ix ? REQ_LSTAT : REQ_STAT;	606	req->type = ix;
531	req->data = newSVsv (fh_or_path);	607	req->data = newSVsv (fh_or_path);
532	req->dataptr = SvPV_nolen (req->data);	608	req->dataptr = SvPV_nolen (req->data);
533	}	609	}
534	else	610	else
535	{	611	{
536	req->type = REQ_FSTAT;	612	req->type = REQ_FSTAT;
		613	req->fh = newSVsv (fh_or_path);
537	req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));	614	req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
538	}	615	}
539		616
540	req->callback = SvREFCNT_inc (callback);	617	req->callback = SvREFCNT_inc (callback);
541		618
542	send_req (req);	619	send_req (req);
543	}	620	}
544		621
545	void	622	void
546	aio_unlink(pathname,callback)	623	aio_unlink(pathname,callback=&PL_sv_undef)
547	SV * pathname	624	SV * pathname
548	SV * callback	625	SV * callback
549	PROTOTYPE: $$
550	CODE:	626	CODE:
551	{	627	{
552	aio_req req;	628	aio_req req;
553		629
554	Newz (0, req, 1, aio_cb);	630	Newz (0, req, 1, aio_cb);
…		…
562	req->callback = SvREFCNT_inc (callback);	638	req->callback = SvREFCNT_inc (callback);
563		639
564	send_req (req);	640	send_req (req);
565	}	641	}
566		642
		643	void
		644	flush()
		645	PROTOTYPE:
		646	CODE:
		647	while (nreqs)
		648	{
		649	poll_wait ();
		650	poll_cb ();
		651	}
		652
		653	void
		654	poll()
		655	PROTOTYPE:
		656	CODE:
		657	if (nreqs)
		658	{
		659	poll_wait ();
		660	poll_cb ();
		661	}
		662
567	int	663	int
568	poll_fileno()	664	poll_fileno()
569	PROTOTYPE:	665	PROTOTYPE:
570	CODE:	666	CODE:
571	RETVAL = respipe [0];	667	RETVAL = respipe [0];
…		…
574		670
575	int	671	int
576	poll_cb(...)	672	poll_cb(...)
577	PROTOTYPE:	673	PROTOTYPE:
578	CODE:	674	CODE:
579	RETVAL = poll_cb (aTHX);	675	RETVAL = poll_cb ();
580	OUTPUT:	676	OUTPUT:
581	RETVAL	677	RETVAL
582		678
583	void	679	void
584	poll_wait()	680	poll_wait()

Diff Legend

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

Comparing IO-AIO/AIO.xs (file contents): Revision 1.3 by root, Sun Jul 10 20:07:11 2005 UTC vs. Revision 1.17 by root, Sun Jul 31 18:45:48 2005 UTC

Diff Legend

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.3 by root, Sun Jul 10 20:07:11 2005 UTC vs.
Revision 1.17 by root, Sun Jul 31 18:45:48 2005 UTC