ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.xs
(Generate patch)

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.110 by root, Sun Dec 2 20:54:33 2007 UTC vs.
Revision 1.114 by root, Sat Apr 26 12:00:23 2008 UTC

… …
189 189
190static thread_t main_tid; 190static thread_t main_tid;
191static int main_sig; 191static int main_sig;
192static int block_sig_level; 192static int block_sig_level;
193 193
194void block_sig () 194void block_sig (void)
195{ 195{
196 sigset_t ss; 196 sigset_t ss;
197 197
198 if (block_sig_level++) 198 if (block_sig_level++)
199 return; 199 return;
… …
204 sigemptyset (&ss); 204 sigemptyset (&ss);
205 sigaddset (&ss, main_sig); 205 sigaddset (&ss, main_sig);
206 pthread_sigmask (SIG_BLOCK, &ss, 0); 206 pthread_sigmask (SIG_BLOCK, &ss, 0);
207} 207}
208 208
209void unblock_sig () 209void unblock_sig (void)
210{ 210{
211 sigset_t ss; 211 sigset_t ss;
212 212
213 if (--block_sig_level) 213 if (--block_sig_level)
214 return; 214 return;
… …
274static mutex_t reqlock = X_MUTEX_INIT; 274static mutex_t reqlock = X_MUTEX_INIT;
275static cond_t reqwait = X_COND_INIT; 275static cond_t reqwait = X_COND_INIT;
276 276
277#if WORDACCESS_UNSAFE 277#if WORDACCESS_UNSAFE
278 278
279static unsigned int get_nready () 279static unsigned int get_nready (void)
280{ 280{
281 unsigned int retval; 281 unsigned int retval;
282 282
283 X_LOCK (reqlock); 283 X_LOCK (reqlock);
284 retval = nready; 284 retval = nready;
285 X_UNLOCK (reqlock); 285 X_UNLOCK (reqlock);
286 286
287 return retval; 287 return retval;
288} 288}
289 289
290static unsigned int get_npending () 290static unsigned int get_npending (void)
291{ 291{
292 unsigned int retval; 292 unsigned int retval;
293 293
294 X_LOCK (reslock); 294 X_LOCK (reslock);
295 retval = npending; 295 retval = npending;
296 X_UNLOCK (reslock); 296 X_UNLOCK (reslock);
297 297
298 return retval; 298 return retval;
299} 299}
300 300
301static unsigned int get_nthreads () 301static unsigned int get_nthreads (void)
302{ 302{
303 unsigned int retval; 303 unsigned int retval;
304 304
305 X_LOCK (wrklock); 305 X_LOCK (wrklock);
306 retval = started; 306 retval = started;
… …
369 } 369 }
370 370
371 abort (); 371 abort ();
372} 372}
373 373
374static int poll_cb (); 374static int poll_cb (void);
375static int req_invoke (aio_req req); 375static int req_invoke (aio_req req);
376static void req_destroy (aio_req req); 376static void req_destroy (aio_req req);
377static void req_cancel (aio_req req); 377static void req_cancel (aio_req req);
378 378
379/* must be called at most once */ 379/* must be called at most once */
… …
653#else 653#else
654# define TO_SOCKET(x) (x) 654# define TO_SOCKET(x) (x)
655#endif 655#endif
656 656
657static void 657static void
658create_respipe () 658create_respipe (void)
659{ 659{
660 int old_readfd = respipe [0]; 660 int old_readfd = respipe [0];
661 661
662 if (respipe [1] >= 0) 662 if (respipe [1] >= 0)
663 respipe_close (TO_SOCKET (respipe [1])); 663 respipe_close (TO_SOCKET (respipe [1]));
… …
715 free (wrk); 715 free (wrk);
716 716
717 X_UNLOCK (wrklock); 717 X_UNLOCK (wrklock);
718} 718}
719 719
720static void maybe_start_thread () 720static void maybe_start_thread (void)
721{ 721{
722 if (get_nthreads () >= wanted) 722 if (get_nthreads () >= wanted)
723 return; 723 return;
724 724
725 /* todo: maybe use idle here, but might be less exact */ 725 /* todo: maybe use idle here, but might be less exact */
… …
785 785
786 while (started > wanted) 786 while (started > wanted)
787 end_thread (); 787 end_thread ();
788} 788}
789 789
790static void poll_wait () 790static void poll_wait (void)
791{ 791{
792 fd_set rfd; 792 fd_set rfd;
793 793
794 while (nreqs) 794 while (nreqs)
795 { 795 {
… …
808 808
809 PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0); 809 PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);
810 } 810 }
811} 811}
812 812
813static int poll_cb () 813static int poll_cb (void)
814{ 814{
815 dSP; 815 dSP;
816 int count = 0; 816 int count = 0;
817 int maxreqs = max_poll_reqs; 817 int maxreqs = max_poll_reqs;
818 int do_croak = 0; 818 int do_croak = 0;
… …
1178 res = -1; 1178 res = -1;
1179 1179
1180 req->result = res; 1180 req->result = res;
1181} 1181}
1182 1182
1183static int
1184aio_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
1183/*****************************************************************************/ 1210/*****************************************************************************/
1184 1211
1185X_THREAD_PROC (aio_proc) 1212X_THREAD_PROC (aio_proc)
1186{ 1213{
1187 {//D
1188 aio_req req; 1214 aio_req req;
1189 struct timespec ts; 1215 struct timespec ts;
1190 worker *self = (worker *)thr_arg; 1216 worker *self = (worker *)thr_arg;
1191 1217
1192 /* try to distribute timeouts somewhat randomly */ 1218 /* try to distribute timeouts somewhat randomly */
… …
1257 case REQ_FCHMOD: req->result = fchmod (req->int1, req->mode); break; 1283 case REQ_FCHMOD: req->result = fchmod (req->int1, req->mode); break;
1258 case REQ_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break; 1284 case REQ_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1259 case REQ_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break; 1285 case REQ_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1260 1286
1261 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;
1262 case REQ_CLOSE: req->result = close (req->int1); break; 1288 case REQ_CLOSE: req->result = aio_close (req->int1); break;
1263 case REQ_UNLINK: req->result = unlink (req->ptr1); break; 1289 case REQ_UNLINK: req->result = unlink (req->ptr1); break;
1264 case REQ_RMDIR: req->result = rmdir (req->ptr1); break; 1290 case REQ_RMDIR: req->result = rmdir (req->ptr1); break;
1265 case REQ_MKDIR: req->result = mkdir (req->ptr1, req->mode); break; 1291 case REQ_MKDIR: req->result = mkdir (req->ptr1, req->mode); break;
1266 case REQ_RENAME: req->result = rename (req->ptr2, req->ptr1); break; 1292 case REQ_RENAME: req->result = rename (req->ptr2, req->ptr1); break;
1267 case REQ_LINK: req->result = link (req->ptr2, req->ptr1); break; 1293 case REQ_LINK: req->result = link (req->ptr2, req->ptr1); break;
… …
1352 X_LOCK (wrklock); 1378 X_LOCK (wrklock);
1353 worker_free (self); 1379 worker_free (self);
1354 X_UNLOCK (wrklock); 1380 X_UNLOCK (wrklock);
1355 1381
1356 return 0; 1382 return 0;
1357 }//D
1358} 1383}
1359 1384
1360/*****************************************************************************/ 1385/*****************************************************************************/
1361 1386
1362static void atfork_prepare (void) 1387static void atfork_prepare (void)
… …
1536 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 1561 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1537 1562
1538 REQ_SEND (req); 1563 REQ_SEND (req);
1539} 1564}
1540 1565
1541int
1542_dup (int fd)
1543 PROTOTYPE: $
1544 CODE:
1545 RETVAL = dup (fd);
1546 OUTPUT:
1547 RETVAL
1548
1549void 1566void
1550_aio_close (int fd, SV *callback=&PL_sv_undef) 1567aio_close (SV *fh, SV *callback=&PL_sv_undef)
1551 PROTOTYPE: $;$ 1568 PROTOTYPE: $;$
1552 PPCODE: 1569 PPCODE:
1553{ 1570{
1554 dREQ; 1571 dREQ;
1555 1572
1556 req->type = REQ_CLOSE; 1573 req->type = REQ_CLOSE;
1557 req->int1 = fd; 1574 req->sv1 = newSVsv (fh);
1575 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1558 1576
1559 REQ_SEND (req); 1577 REQ_SEND (req);
1560} 1578}
1561 1579
1562void 1580void
… …
1992 2010
1993 block_sig (); 2011 block_sig ();
1994 PUSHMARK (SP); 2012 PUSHMARK (SP);
1995 PUTBACK; 2013 PUTBACK;
1996 count = call_sv (cb, GIMME_V | G_NOARGS | G_EVAL); 2014 count = call_sv (cb, GIMME_V | G_NOARGS | G_EVAL);
1997 SPAGAIN;
1998 unblock_sig (); 2015 unblock_sig ();
1999 2016
2000 if (SvTRUE (ERRSV)) 2017 if (SvTRUE (ERRSV))
2001 croak (0); 2018 croak (0);
2002 2019

Diff Legend

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