tee: improve throughput by raw syscall

Author: oech3

src/uu/tee/Cargo.toml

@@ -21,12 +21,12 @@ doctest = false
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["libc", "parser", "signals"] }
+rustix = { workspace = true, features = ["stdio", "fs"] }
+uucore = { workspace = true, features = ["fs", "libc", "parser", "signals"] }
 fluent = { workspace = true }
 
 [dev-dependencies]
 divan = { workspace = true }
-rustix = { workspace = true, features = ["stdio", "fs"] }
 tempfile = { workspace = true }
 uucore = { workspace = true, features = ["benchmark"] }
 

src/uu/tee/src/tee.rs

@@ -197,21 +197,16 @@ impl MultiWriter {
 
     fn write_flush(&mut self, buf: &[u8]) -> Result<()> {
         let mode = self.output_error_mode;
-        self.writers.retain_mut(|writer| {
-            let res = (|| {
-                writer.inner.write_all(buf)?;
-                writer.inner.flush()
-            })();
-            match res {
+        self.writers
+            .retain_mut(|writer| match writer.inner.write_all(buf) {
                 Ok(()) => true,
                 Err(e) => {
                     if let Err(e) = process_error(mode, e, writer, &mut self.ignored_errors) {
                         self.aborted.get_or_insert(e);
                     }
                     false
                 }
-            }
-        });
+            });
         self.aborted.take().map_or(
             if self.writers.is_empty() {
                 // This error kind will never be raised by the standard
@@ -254,18 +249,29 @@ enum Writer {
     Stdout(std::io::Stdout),
 }
 
-impl Write for Writer {
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+// raw syscall avoids buffering which is POSIX requirement
+// throughput is better than flush after write_all by unknown reason
+#[cfg(any(unix, target_os = "wasi"))]
+impl Writer {
+    pub fn write_all(&mut self, buf: &[u8]) -> Result<()> {
         match self {
-            Self::File(f) => f.write(buf),
-            Self::Stdout(s) => s.write(buf),
+            Self::File(f) => uucore::io::write_all_raw(f, buf),
+            Self::Stdout(s) => uucore::io::write_all_raw(s, buf),
         }
     }
+}
 
-    fn flush(&mut self) -> Result<()> {
+#[cfg(not(any(unix, target_os = "wasi")))]
+impl Writer {
+    // override write_all to avoid calling many flush
+    pub fn write_all(&mut self, buf: &[u8]) -> Result<()> {
         match self {
-            Self::File(f) => f.flush(),
-            Self::Stdout(s) => s.flush(),
+            // File does not have line buffering
+            Self::File(f) => f.write_all(buf),
+            Self::Stdout(s) => {
+                s.write_all(buf)?;
+                s.flush() // todo: investigate how to remove flush overhead
+            }
         }
     }
 }

src/uucore/src/lib/mods/io.rs

@@ -30,7 +30,24 @@ type NativeType = OwnedHandle;
 #[cfg(not(windows))]
 type NativeType = OwnedFd;
 
+// io::write_all but no buffering
+#[inline]
+#[cfg(any(unix, target_os = "wasi"))]
+pub fn write_all_raw(output: impl AsFd, buf: &[u8]) -> io::Result<()> {
+    let mut written = 0;
+    let len = buf.len();
+    while written < len {
+        match rustix::io::write(&output, &buf[written..]) {
+            Ok(n) => written += n,
+            Err(e) if e.kind() != io::ErrorKind::Interrupted => return Err(e.into()),
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
 /// abstraction wrapper for native file handle / file descriptor
+// todo: remove clone introducing additional syscall dependency
 pub struct OwnedFileDescriptorOrHandle {
     fx: NativeType,
 }