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

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.106 by root, Mon Sep 24 18:14:00 2007 UTC vs.
Revision 1.114 by root, Sat Apr 26 12:00:23 2008 UTC

…		…
97	# define SvVAL64 SvIV	97	# define SvVAL64 SvIV
98	#else	98	#else
99	# define SvVAL64 SvNV	99	# define SvVAL64 SvNV
100	#endif	100	#endif
101		101
		102	static HV *stash;
		103
102	#define dBUF \	104	#define dBUF \
103	char *aio_buf; \	105	char *aio_buf; \
104	X_LOCK (wrklock); \	106	X_LOCK (wrklock); \
105	self->dbuf = aio_buf = malloc (AIO_BUFSIZE); \	107	self->dbuf = aio_buf = malloc (AIO_BUFSIZE); \
106	X_UNLOCK (wrklock); \	108	X_UNLOCK (wrklock); \
…		…
117	REQ_STAT, REQ_LSTAT, REQ_FSTAT,	119	REQ_STAT, REQ_LSTAT, REQ_FSTAT,
118	REQ_TRUNCATE, REQ_FTRUNCATE,	120	REQ_TRUNCATE, REQ_FTRUNCATE,
119	REQ_UTIME, REQ_FUTIME,	121	REQ_UTIME, REQ_FUTIME,
120	REQ_CHMOD, REQ_FCHMOD,	122	REQ_CHMOD, REQ_FCHMOD,
121	REQ_CHOWN, REQ_FCHOWN,	123	REQ_CHOWN, REQ_FCHOWN,
122	REQ_FSYNC, REQ_FDATASYNC,	124	REQ_SYNC, REQ_FSYNC, REQ_FDATASYNC,
123	REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME,	125	REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME,
124	REQ_MKNOD, REQ_READDIR,	126	REQ_MKNOD, REQ_READDIR,
125	REQ_LINK, REQ_SYMLINK, REQ_READLINK,	127	REQ_LINK, REQ_SYMLINK, REQ_READLINK,
126	REQ_GROUP, REQ_NOP,	128	REQ_GROUP, REQ_NOP,
127	REQ_BUSY,	129	REQ_BUSY,
…		…
187		189
188	static thread_t main_tid;	190	static thread_t main_tid;
189	static int main_sig;	191	static int main_sig;
190	static int block_sig_level;	192	static int block_sig_level;
191		193
192	void block_sig ()	194	void block_sig (void)
193	{	195	{
194	sigset_t ss;	196	sigset_t ss;
195		197
196	if (block_sig_level++)	198	if (block_sig_level++)
197	return;	199	return;
…		…
202	sigemptyset (&ss);	204	sigemptyset (&ss);
203	sigaddset (&ss, main_sig);	205	sigaddset (&ss, main_sig);
204	pthread_sigmask (SIG_BLOCK, &ss, 0);	206	pthread_sigmask (SIG_BLOCK, &ss, 0);
205	}	207	}
206		208
207	void unblock_sig ()	209	void unblock_sig (void)
208	{	210	{
209	sigset_t ss;	211	sigset_t ss;
210		212
211	if (--block_sig_level)	213	if (--block_sig_level)
212	return;	214	return;
…		…
272	static mutex_t reqlock = X_MUTEX_INIT;	274	static mutex_t reqlock = X_MUTEX_INIT;
273	static cond_t reqwait = X_COND_INIT;	275	static cond_t reqwait = X_COND_INIT;
274		276
275	#if WORDACCESS_UNSAFE	277	#if WORDACCESS_UNSAFE
276		278
277	static unsigned int get_nready ()	279	static unsigned int get_nready (void)
278	{	280	{
279	unsigned int retval;	281	unsigned int retval;
280		282
281	X_LOCK (reqlock);	283	X_LOCK (reqlock);
282	retval = nready;	284	retval = nready;
283	X_UNLOCK (reqlock);	285	X_UNLOCK (reqlock);
284		286
285	return retval;	287	return retval;
286	}	288	}
287		289
288	static unsigned int get_npending ()	290	static unsigned int get_npending (void)
289	{	291	{
290	unsigned int retval;	292	unsigned int retval;
291		293
292	X_LOCK (reslock);	294	X_LOCK (reslock);
293	retval = npending;	295	retval = npending;
294	X_UNLOCK (reslock);	296	X_UNLOCK (reslock);
295		297
296	return retval;	298	return retval;
297	}	299	}
298		300
299	static unsigned int get_nthreads ()	301	static unsigned int get_nthreads (void)
300	{	302	{
301	unsigned int retval;	303	unsigned int retval;
302		304
303	X_LOCK (wrklock);	305	X_LOCK (wrklock);
304	retval = started;	306	retval = started;
…		…
367	}	369	}
368		370
369	abort ();	371	abort ();
370	}	372	}
371		373
372	static int poll_cb ();	374	static int poll_cb (void);
373	static int req_invoke (aio_req req);	375	static int req_invoke (aio_req req);
374	static void req_destroy (aio_req req);	376	static void req_destroy (aio_req req);
375	static void req_cancel (aio_req req);	377	static void req_cancel (aio_req req);
376		378
377	/* must be called at most once */	379	/* must be called at most once */
…		…
501	break;	503	break;
502		504
503	case REQ_OPEN:	505	case REQ_OPEN:
504	{	506	{
505	/* convert fd to fh */	507	/* convert fd to fh */
506	SV *fh;	508	SV *fh = &PL_sv_undef;
507		509
508	PUSHs (sv_2mortal (newSViv (req->result)));	510	if (req->result >= 0)
509	PUTBACK;	511	{
510	call_pv ("IO::AIO::_fd2fh", G_SCALAR \| G_EVAL);	512	GV gv = (GV )sv_newmortal ();
511	SPAGAIN;	513	int flags = req->int1 & (O_RDONLY \| O_WRONLY \| O_RDWR);
		514	char sym [64];
		515	int symlen;
		516
		517	symlen = snprintf (sym, sizeof (sym), "fd#%d", req->result);
		518	gv_init (gv, stash, sym, symlen, 0);
512		519
513	fh = POPs;	520	symlen = snprintf (
514	PUSHMARK (SP);	521	sym,
		522	sizeof (sym),
		523	"%s&=%d",
		524	flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
		525	req->result
		526	);
		527
		528	if (do_open (gv, sym, symlen, 0, 0, 0, 0))
		529	fh = (SV *)gv;
		530	}
		531
515	XPUSHs (fh);	532	PUSHs (fh);
516	}	533	}
517	break;	534	break;
518		535
519	case REQ_GROUP:	536	case REQ_GROUP:
520	req->int1 = 2; /* mark group as finished */	537	req->int1 = 2; /* mark group as finished */
…		…
564	}	581	}
565		582
566	errno = req->errorno;	583	errno = req->errorno;
567		584
568	PUTBACK;	585	PUTBACK;
569	call_sv (req->callback, G_VOID \| G_EVAL);	586	call_sv (req->callback, G_VOID \| G_EVAL \| G_DISCARD);
570	SPAGAIN;	587	SPAGAIN;
571		588
572	FREETMPS;	589	FREETMPS;
573	LEAVE;	590	LEAVE;
		591
		592	PUTBACK;
574	}	593	}
575		594
576	if (req->grp)	595	if (req->grp)
577	{	596	{
578	aio_req grp = req->grp;	597	aio_req grp = req->grp;
…		…
634	#else	653	#else
635	# define TO_SOCKET(x) (x)	654	# define TO_SOCKET(x) (x)
636	#endif	655	#endif
637		656
638	static void	657	static void
639	create_respipe ()	658	create_respipe (void)
640	{	659	{
641	int old_readfd = respipe [0];	660	int old_readfd = respipe [0];
642		661
643	if (respipe [1] >= 0)	662	if (respipe [1] >= 0)
644	respipe_close (TO_SOCKET (respipe [1]));	663	respipe_close (TO_SOCKET (respipe [1]));
…		…
696	free (wrk);	715	free (wrk);
697		716
698	X_UNLOCK (wrklock);	717	X_UNLOCK (wrklock);
699	}	718	}
700		719
701	static void maybe_start_thread ()	720	static void maybe_start_thread (void)
702	{	721	{
703	if (get_nthreads () >= wanted)	722	if (get_nthreads () >= wanted)
704	return;	723	return;
705		724
706	/* todo: maybe use idle here, but might be less exact */	725	/* todo: maybe use idle here, but might be less exact */
…		…
766		785
767	while (started > wanted)	786	while (started > wanted)
768	end_thread ();	787	end_thread ();
769	}	788	}
770		789
771	static void poll_wait ()	790	static void poll_wait (void)
772	{	791	{
773	fd_set rfd;	792	fd_set rfd;
774		793
775	while (nreqs)	794	while (nreqs)
776	{	795	{
…		…
789		808
790	PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);	809	PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);
791	}	810	}
792	}	811	}
793		812
794	static int poll_cb ()	813	static int poll_cb (void)
795	{	814	{
796	dSP;	815	dSP;
797	int count = 0;	816	int count = 0;
798	int maxreqs = max_poll_reqs;	817	int maxreqs = max_poll_reqs;
799	int do_croak = 0;	818	int do_croak = 0;
…		…
1159	res = -1;	1178	res = -1;
1160		1179
1161	req->result = res;	1180	req->result = res;
1162	}	1181	}
1163		1182
		1183	static int
		1184	aio_close (int fd)
		1185	{
		1186	static int close_pipe = -1; /* dummy fd to close fds via dup2 */
		1187
		1188	X_LOCK (wrklock);
		1189
		1190	if (close_pipe < 0)
		1191	{
		1192	int pipefd [2];
		1193
		1194	if (pipe (pipefd) < 0
		1195	\|\| close (pipefd [1]) < 0
		1196	\|\| fcntl (pipefd [0], F_SETFD, FD_CLOEXEC) < 0)
		1197	{
		1198	X_UNLOCK (wrklock);
		1199	return -1;
		1200	}
		1201
		1202	close_pipe = pipefd [0];
		1203	}
		1204
		1205	X_UNLOCK (wrklock);
		1206
		1207	return dup2 (close_pipe, fd) < 0 ? -1 : 0;
		1208	}
		1209
1164	/*****************************************************************************/	1210	/*****************************************************************************/
1165		1211
1166	X_THREAD_PROC (aio_proc)	1212	X_THREAD_PROC (aio_proc)
1167	{	1213	{
1168	{//D
1169	aio_req req;	1214	aio_req req;
1170	struct timespec ts;	1215	struct timespec ts;
1171	worker self = (worker )thr_arg;	1216	worker self = (worker )thr_arg;
1172		1217
1173	/* try to distribute timeouts somewhat randomly */	1218	/* try to distribute timeouts somewhat randomly */
…		…
1238	case REQ_FCHMOD: req->result = fchmod (req->int1, req->mode); break;	1283	case REQ_FCHMOD: req->result = fchmod (req->int1, req->mode); break;
1239	case REQ_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;	1284	case REQ_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1240	case REQ_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;	1285	case REQ_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1241		1286
1242	case REQ_OPEN: req->result = open (req->ptr1, req->int1, req->mode); break;	1287	case REQ_OPEN: req->result = open (req->ptr1, req->int1, req->mode); break;
1243	case REQ_CLOSE: req->result = close (req->int1); break;	1288	case REQ_CLOSE: req->result = aio_close (req->int1); break;
1244	case REQ_UNLINK: req->result = unlink (req->ptr1); break;	1289	case REQ_UNLINK: req->result = unlink (req->ptr1); break;
1245	case REQ_RMDIR: req->result = rmdir (req->ptr1); break;	1290	case REQ_RMDIR: req->result = rmdir (req->ptr1); break;
1246	case REQ_MKDIR: req->result = mkdir (req->ptr1, req->mode); break;	1291	case REQ_MKDIR: req->result = mkdir (req->ptr1, req->mode); break;
1247	case REQ_RENAME: req->result = rename (req->ptr2, req->ptr1); break;	1292	case REQ_RENAME: req->result = rename (req->ptr2, req->ptr1); break;
1248	case REQ_LINK: req->result = link (req->ptr2, req->ptr1); break;	1293	case REQ_LINK: req->result = link (req->ptr2, req->ptr1); break;
1249	case REQ_SYMLINK: req->result = symlink (req->ptr2, req->ptr1); break;	1294	case REQ_SYMLINK: req->result = symlink (req->ptr2, req->ptr1); break;
1250	case REQ_MKNOD: req->result = mknod (req->ptr2, req->mode, (dev_t)req->offs); break;	1295	case REQ_MKNOD: req->result = mknod (req->ptr2, req->mode, (dev_t)req->offs); break;
1251	case REQ_READLINK: req->result = readlink (req->ptr2, req->ptr1, NAME_MAX); break;	1296	case REQ_READLINK: req->result = readlink (req->ptr2, req->ptr1, NAME_MAX); break;
1252		1297
		1298	case REQ_SYNC: req->result = 0; sync (); break;
		1299	case REQ_FSYNC: req->result = fsync (req->int1); break;
1253	case REQ_FDATASYNC: req->result = fdatasync (req->int1); break;	1300	case REQ_FDATASYNC: req->result = fdatasync (req->int1); break;
1254	case REQ_FSYNC: req->result = fsync (req->int1); break;	1301
1255	case REQ_READDIR: scandir_ (req, self); break;	1302	case REQ_READDIR: scandir_ (req, self); break;
1256		1303
1257	case REQ_BUSY:	1304	case REQ_BUSY:
1258	#ifdef _WIN32	1305	#ifdef _WIN32
1259	Sleep (req->nv1 * 1000.);	1306	Sleep (req->nv1 * 1000.);
…		…
1331	X_LOCK (wrklock);	1378	X_LOCK (wrklock);
1332	worker_free (self);	1379	worker_free (self);
1333	X_UNLOCK (wrklock);	1380	X_UNLOCK (wrklock);
1334		1381
1335	return 0;	1382	return 0;
1336	}//D
1337	}	1383	}
1338		1384
1339	/*****************************************************************************/	1385	/*****************************************************************************/
1340		1386
1341	static void atfork_prepare (void)	1387	static void atfork_prepare (void)
…		…
1421		1467
1422	PROTOTYPES: ENABLE	1468	PROTOTYPES: ENABLE
1423		1469
1424	BOOT:	1470	BOOT:
1425	{	1471	{
1426	HV *stash = gv_stashpv ("IO::AIO", 1);	1472	stash = gv_stashpv ("IO::AIO", 1);
1427		1473
1428	newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));	1474	newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));
1429	newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));	1475	newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));
1430	newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));	1476	newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));
1431	newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT));	1477	newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT));
…		…
1499		1545
1500	REQ_SEND;	1546	REQ_SEND;
1501	}	1547	}
1502		1548
1503	void	1549	void
1504	aio_close (SV fh, SV callback=&PL_sv_undef)	1550	aio_fsync (SV fh, SV callback=&PL_sv_undef)
1505	PROTOTYPE: $;$	1551	PROTOTYPE: $;$
1506	ALIAS:	1552	ALIAS:
1507	aio_close = REQ_CLOSE
1508	aio_fsync = REQ_FSYNC	1553	aio_fsync = REQ_FSYNC
1509	aio_fdatasync = REQ_FDATASYNC	1554	aio_fdatasync = REQ_FDATASYNC
1510	PPCODE:	1555	PPCODE:
1511	{	1556	{
1512	dREQ;	1557	dREQ;
1513		1558
1514	req->type = ix;	1559	req->type = ix;
		1560	req->sv1 = newSVsv (fh);
		1561	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
		1562
		1563	REQ_SEND (req);
		1564	}
		1565
		1566	void
		1567	aio_close (SV fh, SV callback=&PL_sv_undef)
		1568	PROTOTYPE: $;$
		1569	PPCODE:
		1570	{
		1571	dREQ;
		1572
		1573	req->type = REQ_CLOSE;
1515	req->sv1 = newSVsv (fh);	1574	req->sv1 = newSVsv (fh);
1516	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));	1575	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1517		1576
1518	REQ_SEND (req);	1577	REQ_SEND (req);
1519	}	1578	}
…		…
1848	XPUSHs (req_sv (req, AIO_GRP_KLASS));	1907	XPUSHs (req_sv (req, AIO_GRP_KLASS));
1849	}	1908	}
1850		1909
1851	void	1910	void
1852	aio_nop (SV *callback=&PL_sv_undef)	1911	aio_nop (SV *callback=&PL_sv_undef)
		1912	ALIAS:
		1913	aio_nop = REQ_NOP
		1914	aio_sync = REQ_SYNC
1853	PPCODE:	1915	PPCODE:
1854	{	1916	{
1855	dREQ;	1917	dREQ;
1856		1918
1857	req->type = REQ_NOP;	1919	req->type = ix;
1858		1920
1859	REQ_SEND;	1921	REQ_SEND;
1860	}	1922	}
1861		1923
1862	int	1924	int
…		…
1948		2010
1949	block_sig ();	2011	block_sig ();
1950	PUSHMARK (SP);	2012	PUSHMARK (SP);
1951	PUTBACK;	2013	PUTBACK;
1952	count = call_sv (cb, GIMME_V \| G_NOARGS \| G_EVAL);	2014	count = call_sv (cb, GIMME_V \| G_NOARGS \| G_EVAL);
1953	SPAGAIN;
1954	unblock_sig ();	2015	unblock_sig ();
1955		2016
1956	if (SvTRUE (ERRSV))	2017	if (SvTRUE (ERRSV))
1957	croak (0);	2018	croak (0);
1958		2019

Diff Legend

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

Comparing IO-AIO/AIO.xs (file contents): Revision 1.106 by root, Mon Sep 24 18:14:00 2007 UTC vs. Revision 1.114 by root, Sat Apr 26 12:00:23 2008 UTC

Diff Legend

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.106 by root, Mon Sep 24 18:14:00 2007 UTC vs.
Revision 1.114 by root, Sat Apr 26 12:00:23 2008 UTC