library/std/src/sys/unix/kernel_copy/tests.rs

   1 use crate::env::temp_dir;
   2 use crate::fs::OpenOptions;
   3 use crate::io;
   4 use crate::io::Result;
   5 use crate::io::SeekFrom;
   6 use crate::io::{BufRead, Read, Seek, Write};
   7 use crate::os::unix::io::AsRawFd;
   8
   9 #[test]
  10 fn copy_specialization() -> Result<()> {
  11     use crate::io::{BufReader, BufWriter};
  12
  13     let path = crate::env::temp_dir();
  14     let source_path = path.join("copy-spec.source");
  15     let sink_path = path.join("copy-spec.sink");
  16
  17     let result: Result<()> = try {
  18         let mut source = crate::fs::OpenOptions::new()
  19             .read(true)
  20             .write(true)
  21             .create(true)
  22             .truncate(true)
  23             .open(&source_path)?;
  24         source.write_all(b"abcdefghiklmnopqr")?;
  25         source.seek(SeekFrom::Start(8))?;
  26         let mut source = BufReader::with_capacity(8, source.take(5));
  27         source.fill_buf()?;
  28         assert_eq!(source.buffer(), b"iklmn");
  29         source.get_mut().set_limit(6);
  30         source.get_mut().get_mut().seek(SeekFrom::Start(1))?; // "bcdefg"
  31         let mut source = source.take(10); // "iklmnbcdef"
  32
  33         let mut sink = crate::fs::OpenOptions::new()
  34             .read(true)
  35             .write(true)
  36             .create(true)
  37             .truncate(true)
  38             .open(&sink_path)?;
  39         sink.write_all(b"000000")?;
  40         let mut sink = BufWriter::with_capacity(5, sink);
  41         sink.write_all(b"wxyz")?;
  42         assert_eq!(sink.buffer(), b"wxyz");
  43
  44         let copied = crate::io::copy(&mut source, &mut sink)?;
  45         assert_eq!(copied, 10, "copy obeyed limit imposed by Take");
  46         assert_eq!(sink.buffer().len(), 0, "sink buffer was flushed");
  47         assert_eq!(source.limit(), 0, "outer Take was exhausted");
  48         assert_eq!(source.get_ref().buffer().len(), 0, "source buffer should be drained");
  49         assert_eq!(
  50             source.get_ref().get_ref().limit(),
  51             1,
  52             "inner Take allowed reading beyond end of file, some bytes should be left"
  53         );
  54
  55         let mut sink = sink.into_inner()?;
  56         sink.seek(SeekFrom::Start(0))?;
  57         let mut copied = Vec::new();
  58         sink.read_to_end(&mut copied)?;
  59         assert_eq!(&copied, b"000000wxyziklmnbcdef");
  60     };
  61
  62     let rm1 = crate::fs::remove_file(source_path);
  63     let rm2 = crate::fs::remove_file(sink_path);
  64
  65     result.and(rm1).and(rm2)
  66 }
  67
  68 #[bench]
  69 fn bench_file_to_file_copy(b: &mut test::Bencher) {
  70     const BYTES: usize = 128 * 1024;
  71     let src_path = temp_dir().join("file-copy-bench-src");
  72     let mut src = crate::fs::OpenOptions::new()
  73         .create(true)
  74         .truncate(true)
  75         .read(true)
  76         .write(true)
  77         .open(src_path)
  78         .unwrap();
  79     src.write(&vec![0u8; BYTES]).unwrap();
  80
  81     let sink_path = temp_dir().join("file-copy-bench-sink");
  82     let mut sink = crate::fs::OpenOptions::new()
  83         .create(true)
  84         .truncate(true)
  85         .write(true)
  86         .open(sink_path)
  87         .unwrap();
  88
  89     b.bytes = BYTES as u64;
  90     b.iter(|| {
  91         src.seek(SeekFrom::Start(0)).unwrap();
  92         sink.seek(SeekFrom::Start(0)).unwrap();
  93         assert_eq!(BYTES as u64, io::copy(&mut src, &mut sink).unwrap());
  94     });
  95 }
  96
  97 #[bench]
  98 fn bench_file_to_socket_copy(b: &mut test::Bencher) {
  99     const BYTES: usize = 128 * 1024;
 100     let src_path = temp_dir().join("pipe-copy-bench-src");
 101     let mut src = OpenOptions::new()
 102         .create(true)
 103         .truncate(true)
 104         .read(true)
 105         .write(true)
 106         .open(src_path)
 107         .unwrap();
 108     src.write(&vec![0u8; BYTES]).unwrap();
 109
 110     let sink_drainer = crate::net::TcpListener::bind("localhost:0").unwrap();
 111     let mut sink = crate::net::TcpStream::connect(sink_drainer.local_addr().unwrap()).unwrap();
 112     let mut sink_drainer = sink_drainer.accept().unwrap().0;
 113
 114     crate::thread::spawn(move || {
 115         let mut sink_buf = vec![0u8; 1024 * 1024];
 116         loop {
 117             sink_drainer.read(&mut sink_buf[..]).unwrap();
 118         }
 119     });
 120
 121     b.bytes = BYTES as u64;
 122     b.iter(|| {
 123         src.seek(SeekFrom::Start(0)).unwrap();
 124         assert_eq!(BYTES as u64, io::copy(&mut src, &mut sink).unwrap());
 125     });
 126 }
 127
 128 #[bench]
 129 fn bench_file_to_uds_copy(b: &mut test::Bencher) {
 130     const BYTES: usize = 128 * 1024;
 131     let src_path = temp_dir().join("uds-copy-bench-src");
 132     let mut src = OpenOptions::new()
 133         .create(true)
 134         .truncate(true)
 135         .read(true)
 136         .write(true)
 137         .open(src_path)
 138         .unwrap();
 139     src.write(&vec![0u8; BYTES]).unwrap();
 140
 141     let (mut sink, mut sink_drainer) = crate::os::unix::net::UnixStream::pair().unwrap();
 142
 143     crate::thread::spawn(move || {
 144         let mut sink_buf = vec![0u8; 1024 * 1024];
 145         loop {
 146             sink_drainer.read(&mut sink_buf[..]).unwrap();
 147         }
 148     });
 149
 150     b.bytes = BYTES as u64;
 151     b.iter(|| {
 152         src.seek(SeekFrom::Start(0)).unwrap();
 153         assert_eq!(BYTES as u64, io::copy(&mut src, &mut sink).unwrap());
 154     });
 155 }
 156
 157 #[cfg(any(target_os = "linux", target_os = "android"))]
 158 #[bench]
 159 fn bench_socket_pipe_socket_copy(b: &mut test::Bencher) {
 160     use super::CopyResult;
 161     use crate::io::ErrorKind;
 162     use crate::process::{ChildStdin, ChildStdout};
 163     use crate::sys_common::FromInner;
 164
 165     let (read_end, write_end) = crate::sys::pipe::anon_pipe().unwrap();
 166
 167     let mut read_end = ChildStdout::from_inner(read_end);
 168     let write_end = ChildStdin::from_inner(write_end);
 169
 170     let acceptor = crate::net::TcpListener::bind("localhost:0").unwrap();
 171     let mut remote_end = crate::net::TcpStream::connect(acceptor.local_addr().unwrap()).unwrap();
 172
 173     let local_end = crate::sync::Arc::new(acceptor.accept().unwrap().0);
 174
 175     // the data flow in this benchmark:
 176     //
 177     //                      socket(tx)  local_source
 178     // remote_end (write)  +-------->   (splice to)
 179     //                                  write_end
 180     //                                     +
 181     //                                     |
 182     //                                     | pipe
 183     //                                     v
 184     //                                  read_end
 185     // remote_end (read)   <---------+  (splice to) *
 186     //                      socket(rx)  local_end
 187     //
 188     // * benchmark loop using io::copy
 189
 190     crate::thread::spawn(move || {
 191         let mut sink_buf = vec![0u8; 1024 * 1024];
 192         remote_end.set_nonblocking(true).unwrap();
 193         loop {
 194             match remote_end.write(&mut sink_buf[..]) {
 195                 Err(err) if err.kind() == ErrorKind::WouldBlock => {}
 196                 Ok(_) => {}
 197                 err => {
 198                     err.expect("write failed");
 199                 }
 200             };
 201             match remote_end.read(&mut sink_buf[..]) {
 202                 Err(err) if err.kind() == ErrorKind::WouldBlock => {}
 203                 Ok(_) => {}
 204                 err => {
 205                     err.expect("read failed");
 206                 }
 207             };
 208         }
 209     });
 210
 211     // check that splice works, otherwise the benchmark would hang
 212     let probe = super::sendfile_splice(
 213         super::SpliceMode::Splice,
 214         local_end.as_raw_fd(),
 215         write_end.as_raw_fd(),
 216         1,
 217     );
 218
 219     match probe {
 220         CopyResult::Ended(1) => {
 221             // splice works
 222         }
 223         _ => {
 224             eprintln!("splice failed, skipping benchmark");
 225             return;
 226         }
 227     }
 228
 229     let local_source = local_end.clone();
 230     crate::thread::spawn(move || {
 231         loop {
 232             super::sendfile_splice(
 233                 super::SpliceMode::Splice,
 234                 local_source.as_raw_fd(),
 235                 write_end.as_raw_fd(),
 236                 u64::MAX,
 237             );
 238         }
 239     });
 240
 241     const BYTES: usize = 128 * 1024;
 242     b.bytes = BYTES as u64;
 243     b.iter(|| {
 244         assert_eq!(
 245             BYTES as u64,
 246             io::copy(&mut (&mut read_end).take(BYTES as u64), &mut &*local_end).unwrap()
 247         );
 248     });
 249 }