[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.20 by root, Sun Jul 31 19:08:39 2005 UTC

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