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.29 by root, Wed Aug 17 06:12:10 2005 UTC vs.
Revision 1.38 by root, Sun Aug 28 10:51:33 2005 UTC

… …
5#include "perl.h" 5#include "perl.h"
6#include "XSUB.h" 6#include "XSUB.h"
7 7
8#include "autoconf/config.h" 8#include "autoconf/config.h"
9 9
10#include <pthread.h>
11
12#include <stddef.h>
10#include <sys/types.h> 13#include <sys/types.h>
11#include <sys/stat.h> 14#include <sys/stat.h>
12 15#include <limits.h>
13#include <unistd.h> 16#include <unistd.h>
14#include <fcntl.h> 17#include <fcntl.h>
15#include <signal.h> 18#include <signal.h>
16#include <sched.h> 19#include <sched.h>
17 20
18#include <pthread.h> 21#if HAVE_SENDFILE
19 22# if __linux
20typedef void *InputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 23# include <sys/sendfile.h>
21typedef void *OutputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 24# elif __freebsd
22typedef void *InOutStream; /* hack, but 5.6.1 is simply toooo old ;) */ 25# include <sys/socket.h>
26# include <sys/uio.h>
27# elif __hpux
28# include <sys/socket.h>
29# elif __solaris /* not yet */
30# include <sys/sendfile.h>
31# else
32# error sendfile support requested but not available
33# endif
34#endif
23 35
24#if __ia64 36#if __ia64
25# define STACKSIZE 65536 37# define STACKSIZE 65536
26#else 38#else
27# define STACKSIZE 4096 39# define STACKSIZE 8192
28#endif 40#endif
29 41
30enum { 42enum {
31 REQ_QUIT, 43 REQ_QUIT,
32 REQ_OPEN, REQ_CLOSE, 44 REQ_OPEN, REQ_CLOSE,
33 REQ_READ, REQ_WRITE, REQ_READAHEAD, 45 REQ_READ, REQ_WRITE, REQ_READAHEAD,
46 REQ_SENDFILE,
34 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 47 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
35 REQ_FSYNC, REQ_FDATASYNC, 48 REQ_FSYNC, REQ_FDATASYNC,
36 REQ_UNLINK, REQ_RMDIR, 49 REQ_UNLINK, REQ_RMDIR,
50 REQ_READDIR,
37 REQ_SYMLINK, 51 REQ_SYMLINK,
38}; 52};
39 53
40typedef struct aio_cb { 54typedef struct aio_cb {
41 struct aio_cb *volatile next; 55 struct aio_cb *volatile next;
42 56
43 int type; 57 int type;
44 58
59 /* should receive a cleanup, with unions */
45 int fd; 60 int fd, fd2;
46 off_t offset; 61 off_t offset;
47 size_t length; 62 size_t length;
48 ssize_t result; 63 ssize_t result;
49 mode_t mode; /* open */ 64 mode_t mode; /* open */
50 int errorno; 65 int errorno;
51 SV *data, *callback, *fh; 66 SV *data, *callback;
67 SV *fh, *fh2;
52 void *dataptr, *data2ptr; 68 void *dataptr, *data2ptr;
53 STRLEN dataoffset; 69 STRLEN dataoffset;
54 70
55 Stat_t *statdata; 71 Stat_t *statdata;
56} aio_cb; 72} aio_cb;
57 73
58typedef aio_cb *aio_req; 74typedef aio_cb *aio_req;
59 75
60static int started; 76static int started, wanted;
61static volatile int nreqs; 77static volatile int nreqs;
62static int max_outstanding = 1<<30; 78static int max_outstanding = 1<<30;
63static int respipe [2]; 79static int respipe [2];
64 80
65static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER; 81static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER;
… …
75 SvREFCNT_dec (req->data); 91 SvREFCNT_dec (req->data);
76 92
77 if (req->fh) 93 if (req->fh)
78 SvREFCNT_dec (req->fh); 94 SvREFCNT_dec (req->fh);
79 95
96 if (req->fh2)
97 SvREFCNT_dec (req->fh2);
98
80 if (req->statdata) 99 if (req->statdata)
81 Safefree (req->statdata); 100 Safefree (req->statdata);
82 101
83 if (req->callback) 102 if (req->callback)
84 SvREFCNT_dec (req->callback); 103 SvREFCNT_dec (req->callback);
104
105 if (req->type == REQ_READDIR && req->result >= 0)
106 free (req->data2ptr);
85 107
86 Safefree (req); 108 Safefree (req);
87} 109}
88 110
89static void 111static void
… …
116 { 138 {
117 ress = req->next; 139 ress = req->next;
118 140
119 if (!ress) 141 if (!ress)
120 { 142 {
121 rese = 0;
122
123 /* read any signals sent by the worker threads */ 143 /* read any signals sent by the worker threads */
124 char buf [32]; 144 char buf [32];
125 while (read (respipe [0], buf, 32) == 32) 145 while (read (respipe [0], buf, 32) == 32)
126 ; 146 ;
147
148 rese = 0;
127 } 149 }
128 } 150 }
129 151
130 pthread_mutex_unlock (&reslock); 152 pthread_mutex_unlock (&reslock);
131 153
… …
154 PL_statcache = *(req->statdata); 176 PL_statcache = *(req->statdata);
155 } 177 }
156 178
157 ENTER; 179 ENTER;
158 PUSHMARK (SP); 180 PUSHMARK (SP);
159 XPUSHs (sv_2mortal (newSViv (req->result)));
160 181
161 if (req->type == REQ_OPEN) 182 if (req->type == REQ_READDIR)
162 { 183 {
184 SV *rv = &PL_sv_undef;
185
186 if (req->result >= 0)
187 {
188 char *buf = req->data2ptr;
189 AV *av = newAV ();
190
191 while (req->result)
192 {
193 SV *sv = newSVpv (buf, 0);
194
195 av_push (av, sv);
196 buf += SvCUR (sv) + 1;
197 req->result--;
198 }
199
200 rv = sv_2mortal (newRV_noinc ((SV *)av));
201 }
202
203 XPUSHs (rv);
204 }
205 else
206 {
207 XPUSHs (sv_2mortal (newSViv (req->result)));
208
209 if (req->type == REQ_OPEN)
210 {
163 /* convert fd to fh */ 211 /* convert fd to fh */
164 SV *fh; 212 SV *fh;
165 213
166 PUTBACK; 214 PUTBACK;
167 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL); 215 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
168 SPAGAIN; 216 SPAGAIN;
169 217
170 fh = SvREFCNT_inc (POPs); 218 fh = SvREFCNT_inc (POPs);
171 219
172 PUSHMARK (SP); 220 PUSHMARK (SP);
173 XPUSHs (sv_2mortal (fh)); 221 XPUSHs (sv_2mortal (fh));
222 }
174 } 223 }
175 224
176 if (SvOK (req->callback)) 225 if (SvOK (req->callback))
177 { 226 {
178 PUTBACK; 227 PUTBACK;
… …
221} 270}
222 271
223static void 272static void
224send_req (aio_req req) 273send_req (aio_req req)
225{ 274{
275 while (started < wanted && nreqs >= started)
276 start_thread ();
277
226 nreqs++; 278 nreqs++;
227 279
228 pthread_mutex_lock (&reqlock); 280 pthread_mutex_lock (&reqlock);
229 281
230 req->next = 0; 282 req->next = 0;
… …
262 send_req (req); 314 send_req (req);
263} 315}
264 316
265static void min_parallel (int nthreads) 317static void min_parallel (int nthreads)
266{ 318{
267 while (nthreads > started) 319 if (wanted < nthreads)
268 start_thread (); 320 wanted = nthreads;
269} 321}
270 322
271static void max_parallel (int nthreads) 323static void max_parallel (int nthreads)
272{ 324{
273 int cur = started; 325 int cur = started;
274 326
327 if (wanted > nthreads)
328 wanted = nthreads;
329
275 while (cur > nthreads) 330 while (cur > wanted)
276 { 331 {
277 end_thread (); 332 end_thread ();
278 cur--; 333 cur--;
279 } 334 }
280 335
281 while (started > nthreads) 336 while (started > wanted)
282 { 337 {
283 poll_wait (); 338 poll_wait ();
284 poll_cb (); 339 poll_cb ();
285 } 340 }
286} 341}
… …
293 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK)) 348 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK))
294 croak ("cannot set result pipe to nonblocking mode"); 349 croak ("cannot set result pipe to nonblocking mode");
295 350
296 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK)) 351 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
297 croak ("cannot set result pipe to nonblocking mode"); 352 croak ("cannot set result pipe to nonblocking mode");
298}
299
300static void atfork_prepare (void)
301{
302 pthread_mutex_lock (&reqlock);
303 pthread_mutex_lock (&reslock);
304}
305
306static void atfork_parent (void)
307{
308 pthread_mutex_unlock (&reslock);
309 pthread_mutex_unlock (&reqlock);
310}
311
312static void atfork_child (void)
313{
314 aio_req prv;
315
316 int restart = started;
317 started = 0;
318
319 while (reqs)
320 {
321 prv = reqs;
322 reqs = prv->next;
323 free_req (prv);
324 }
325
326 reqs = reqe = 0;
327
328 while (ress)
329 {
330 prv = ress;
331 ress = prv->next;
332 free_req (prv);
333 }
334
335 ress = rese = 0;
336
337 close (respipe [0]);
338 close (respipe [1]);
339 create_pipe ();
340
341 atfork_parent ();
342
343 min_parallel (restart);
344} 353}
345 354
346/*****************************************************************************/ 355/*****************************************************************************/
347/* work around various missing functions */ 356/* work around various missing functions */
348 357
… …
353/* 362/*
354 * make our pread/pwrite safe against themselves, but not against 363 * make our pread/pwrite safe against themselves, but not against
355 * normal read/write by using a mutex. slows down execution a lot, 364 * normal read/write by using a mutex. slows down execution a lot,
356 * but that's your problem, not mine. 365 * but that's your problem, not mine.
357 */ 366 */
358static pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER; 367static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
359 368
360static ssize_t 369static ssize_t
361pread (int fd, void *buf, size_t count, off_t offset) 370pread (int fd, void *buf, size_t count, off_t offset)
362{ 371{
363 ssize_t res; 372 ssize_t res;
364 off_t ooffset; 373 off_t ooffset;
365 374
366 pthread_mutex_lock (&iolock); 375 pthread_mutex_lock (&preadwritelock);
367 ooffset = lseek (fd, 0, SEEK_CUR); 376 ooffset = lseek (fd, 0, SEEK_CUR);
368 lseek (fd, offset, SEEK_SET); 377 lseek (fd, offset, SEEK_SET);
369 res = read (fd, buf, count); 378 res = read (fd, buf, count);
370 lseek (fd, ooffset, SEEK_SET); 379 lseek (fd, ooffset, SEEK_SET);
371 pthread_mutex_unlock (&iolock); 380 pthread_mutex_unlock (&preadwritelock);
372 381
373 return res; 382 return res;
374} 383}
375 384
376static ssize_t 385static ssize_t
377pwrite (int fd, void *buf, size_t count, off_t offset) 386pwrite (int fd, void *buf, size_t count, off_t offset)
378{ 387{
379 ssize_t res; 388 ssize_t res;
380 off_t ooffset; 389 off_t ooffset;
381 390
382 pthread_mutex_lock (&iolock); 391 pthread_mutex_lock (&preadwritelock);
383 ooffset = lseek (fd, 0, SEEK_CUR); 392 ooffset = lseek (fd, 0, SEEK_CUR);
384 lseek (fd, offset, SEEK_SET); 393 lseek (fd, offset, SEEK_SET);
385 res = write (fd, buf, count); 394 res = write (fd, buf, count);
386 lseek (fd, offset, SEEK_SET); 395 lseek (fd, offset, SEEK_SET);
387 pthread_mutex_unlock (&iolock); 396 pthread_mutex_unlock (&preadwritelock);
388 397
389 return res; 398 return res;
390} 399}
391#endif 400#endif
392 401
… …
395#endif 404#endif
396 405
397#if !HAVE_READAHEAD 406#if !HAVE_READAHEAD
398# define readahead aio_readahead 407# define readahead aio_readahead
399 408
400static char readahead_buf[4096];
401
402static ssize_t 409static ssize_t
403readahead (int fd, off_t offset, size_t count) 410readahead (int fd, off_t offset, size_t count)
404{ 411{
412 char readahead_buf[4096];
413
405 while (count > 0) 414 while (count > 0)
406 { 415 {
407 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf); 416 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
408 417
409 pread (fd, readahead_buf, len, offset); 418 pread (fd, readahead_buf, len, offset);
… …
412 } 421 }
413 422
414 errno = 0; 423 errno = 0;
415} 424}
416#endif 425#endif
426
427#if !HAVE_READDIR_R
428# define readdir_r aio_readdir_r
429
430static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
431
432static int
433readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
434{
435 struct dirent *e;
436 int errorno;
437
438 pthread_mutex_lock (&readdirlock);
439
440 e = readdir (dirp);
441 errorno = errno;
442
443 if (e)
444 {
445 *res = ent;
446 strcpy (ent->d_name, e->d_name);
447 }
448 else
449 *res = 0;
450
451 pthread_mutex_unlock (&readdirlock);
452
453 errno = errorno;
454 return e ? 0 : -1;
455}
456#endif
457
458/* sendfile always needs emulation */
459static ssize_t
460sendfile_ (int ofd, int ifd, off_t offset, size_t count)
461{
462 ssize_t res;
463
464 if (!count)
465 return 0;
466
467#if HAVE_SENDFILE
468# if __linux
469 res = sendfile (ofd, ifd, &offset, count);
470
471# elif __freebsd
472 /*
473 * Of course, the freebsd sendfile is a dire hack with no thoughts
474 * wasted on making it similar to other I/O functions.
475 */
476 {
477 off_t sbytes;
478 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
479
480 if (res < 0 && sbytes)
481 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
482 res = sbytes;
483 }
484
485# elif __hpux
486 res = sendfile (ofd, ifd, offset, count, 0, 0);
487
488# elif __solaris
489 {
490 struct sendfilevec vec;
491 size_t sbytes;
492
493 vec.sfv_fd = ifd;
494 vec.sfv_flag = 0;
495 vec.sfv_off = offset;
496 vec.sfv_len = count;
497
498 res = sendfilev (ofd, &vec, 1, &sbytes);
499
500 if (res < 0 && sbytes)
501 res = sbytes;
502 }
503
504# endif
505#else
506 res = -1;
507 errno = ENOSYS;
508#endif
509
510 if (res < 0
511 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
512#if __solaris
513 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
514#endif
515 )
516 )
517 {
518 /* emulate sendfile. this is a major pain in the ass */
519 char buf[4096];
520 res = 0;
521
522 while (count)
523 {
524 ssize_t cnt;
525
526 cnt = pread (ifd, buf, count > 4096 ? 4096 : count, offset);
527
528 if (cnt <= 0)
529 {
530 if (cnt && !res) res = -1;
531 break;
532 }
533
534 cnt = write (ofd, buf, cnt);
535
536 if (cnt <= 0)
537 {
538 if (cnt && !res) res = -1;
539 break;
540 }
541
542 offset += cnt;
543 res += cnt;
544 count -= cnt;
545 }
546 }
547
548 return res;
549}
550
551/* read a full directory */
552static int
553scandir_ (const char *path, void **namesp)
554{
555 DIR *dirp = opendir (path);
556 union
557 {
558 struct dirent d;
559 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
560 } u;
561 struct dirent *entp;
562 char *name, *names;
563 int memlen = 4096;
564 int memofs = 0;
565 int res = 0;
566 int errorno;
567
568 if (!dirp)
569 return -1;
570
571 names = malloc (memlen);
572
573 for (;;)
574 {
575 errno = 0, readdir_r (dirp, &u.d, &entp);
576
577 if (!entp)
578 break;
579
580 name = entp->d_name;
581
582 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
583 {
584 int len = strlen (name) + 1;
585
586 res++;
587
588 while (memofs + len > memlen)
589 {
590 memlen *= 2;
591 names = realloc (names, memlen);
592 if (!names)
593 break;
594 }
595
596 memcpy (names + memofs, name, len);
597 memofs += len;
598 }
599 }
600
601 errorno = errno;
602 closedir (dirp);
603
604 if (errorno)
605 {
606 free (names);
607 errno = errorno;
608 res = -1;
609 }
610
611 *namesp = (void *)names;
612 return res;
613}
417 614
418/*****************************************************************************/ 615/*****************************************************************************/
419 616
420static void * 617static void *
421aio_proc (void *thr_arg) 618aio_proc (void *thr_arg)
… …
453 { 650 {
454 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; 651 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
455 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; 652 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
456 653
457 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 654 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
655 case REQ_SENDFILE: req->result = sendfile_ (req->fd, req->fd2, req->offset, req->length); break;
458 656
459 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break; 657 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;
460 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break; 658 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;
461 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break; 659 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;
462 660
… …
466 case REQ_RMDIR: req->result = rmdir (req->dataptr); break; 664 case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
467 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break; 665 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
468 666
469 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; 667 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
470 case REQ_FSYNC: req->result = fsync (req->fd); break; 668 case REQ_FSYNC: req->result = fsync (req->fd); break;
669 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
471 670
472 case REQ_QUIT: 671 case REQ_QUIT:
473 break; 672 break;
474 673
475 default: 674 default:
… …
499 pthread_mutex_unlock (&reslock); 698 pthread_mutex_unlock (&reslock);
500 } 699 }
501 while (type != REQ_QUIT); 700 while (type != REQ_QUIT);
502 701
503 return 0; 702 return 0;
703}
704
705/*****************************************************************************/
706
707static void atfork_prepare (void)
708{
709 pthread_mutex_lock (&reqlock);
710 pthread_mutex_lock (&reslock);
711#if !HAVE_PREADWRITE
712 pthread_mutex_lock (&preadwritelock);
713#endif
714#if !HAVE_READDIR_R
715 pthread_mutex_lock (&readdirlock);
716#endif
717}
718
719static void atfork_parent (void)
720{
721#if !HAVE_READDIR_R
722 pthread_mutex_unlock (&readdirlock);
723#endif
724#if !HAVE_PREADWRITE
725 pthread_mutex_unlock (&preadwritelock);
726#endif
727 pthread_mutex_unlock (&reslock);
728 pthread_mutex_unlock (&reqlock);
729}
730
731static void atfork_child (void)
732{
733 aio_req prv;
734
735 started = 0;
736
737 while (reqs)
738 {
739 prv = reqs;
740 reqs = prv->next;
741 free_req (prv);
742 }
743
744 reqs = reqe = 0;
745
746 while (ress)
747 {
748 prv = ress;
749 ress = prv->next;
750 free_req (prv);
751 }
752
753 ress = rese = 0;
754
755 close (respipe [0]);
756 close (respipe [1]);
757 create_pipe ();
758
759 atfork_parent ();
504} 760}
505 761
506#define dREQ \ 762#define dREQ \
507 aio_req req; \ 763 aio_req req; \
508 \ 764 \
… …
585 841
586void 842void
587aio_read(fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 843aio_read(fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
588 SV * fh 844 SV * fh
589 UV offset 845 UV offset
590 IV length 846 UV length
591 SV * data 847 SV * data
592 IV dataoffset 848 UV dataoffset
593 SV * callback 849 SV * callback
594 ALIAS: 850 ALIAS:
595 aio_read = REQ_READ 851 aio_read = REQ_READ
596 aio_write = REQ_WRITE 852 aio_write = REQ_WRITE
597 PROTOTYPE: $$$$$;$ 853 PROTOTYPE: $$$$$;$
… …
643 req->data2ptr = (void *)data; 899 req->data2ptr = (void *)data;
644 } 900 }
645 901
646 send_req (req); 902 send_req (req);
647 } 903 }
904}
905
906void
907aio_sendfile(out_fh,in_fh,in_offset,length,callback=&PL_sv_undef)
908 SV * out_fh
909 SV * in_fh
910 UV in_offset
911 UV length
912 SV * callback
913 PROTOTYPE: $$$$;$
914 CODE:
915{
916 dREQ;
917
918 req->type = REQ_SENDFILE;
919 req->fh = newSVsv (out_fh);
920 req->fd = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
921 req->fh2 = newSVsv (in_fh);
922 req->fd2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
923 req->offset = in_offset;
924 req->length = length;
925
926 send_req (req);
648} 927}
649 928
650void 929void
651aio_readahead(fh,offset,length,callback=&PL_sv_undef) 930aio_readahead(fh,offset,length,callback=&PL_sv_undef)
652 SV * fh 931 SV * fh
… …
736 1015
737 send_req (req); 1016 send_req (req);
738} 1017}
739 1018
740void 1019void
1020aio_readdir(pathname,callback=&PL_sv_undef)
1021 SV * pathname
1022 SV * callback
1023 CODE:
1024{
1025 dREQ;
1026
1027 req->type = REQ_READDIR;
1028 req->data = newSVsv (pathname);
1029 req->dataptr = SvPVbyte_nolen (req->data);
1030
1031 send_req (req);
1032}
1033
1034void
741flush() 1035flush()
742 PROTOTYPE: 1036 PROTOTYPE:
743 CODE: 1037 CODE:
744 while (nreqs) 1038 while (nreqs)
745 { 1039 {

Diff Legend

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