This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8866

rhg: add buffered stdout writing possibility
ClosedPublic

Authored by acezar on Aug 3 2020, 10:26 AM.

Details

Reviewers
Alphare
indygreg
Group Reviewers
hg-reviewers
Commits
rHGeb55274d3650: rhg: add buffered stdout writing possibility
Summary

Improve batch stdout writing performance.
At some point line buffered output should be introduced.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

acezar created this revision.Aug 3 2020, 10:26 AM
Alphare accepted this revision.Aug 3 2020, 11:10 AM
Alphare added a subscriber: Alphare.

@acezar Do you remember the kind of performance difference we had when adding this? I think it would be interesting to add it to the commit message.

acezar added a comment.EditedAug 4 2020, 4:24 AM

I did not keep the numbers

acezar updated this revision to Diff 22250.Aug 4 2020, 4:58 AM
indygreg accepted this revision.Aug 8 2020, 4:02 PM
This revision is now accepted and ready to land.Aug 8 2020, 4:02 PM
acezar added a commit: rHGeb55274d3650: rhg: add buffered stdout writing possibility.Aug 8 2020, 4:30 PM
Closed by commit rHGeb55274d3650: rhg: add buffered stdout writing possibility (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/rhg/src/ui.rs (71 lines)

Diff 22250

rust/rhg/src/ui.rs

use std::io; use std::io;
use std::io::Write; use std::io::{ErrorKind, Write};
pub struct Ui {} #[derive(Debug)]
pub struct Ui {
stdout: std::io::Stdout,
stderr: std::io::Stderr,
}
/// The kind of user interface error /// The kind of user interface error
pub enum UiError { pub enum UiError {
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError(io::Error), StdoutError(io::Error),
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError(io::Error), StderrError(io::Error),
} }
/// The commandline user interface /// The commandline user interface
impl Ui { impl Ui {
pub fn new() -> Self { pub fn new() -> Self {
Ui {} Ui {
stdout: std::io::stdout(),
stderr: std::io::stderr(),
}
}
/// Returns a buffered handle on stdout for faster batch printing
/// operations.
pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
StdoutBuffer::new(self.stdout.lock())
} }
/// Write bytes to stdout /// Write bytes to stdout
pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stdout = io::stdout(); let mut stdout = self.stdout.lock();
self.write_stream(&mut stdout, bytes) self.write_stream(&mut stdout, bytes)
.or_else(|e| self.into_stdout_error(e))?; .or_else(|e| self.handle_stdout_error(e))?;
stdout.flush().or_else(|e| self.into_stdout_error(e)) stdout.flush().or_else(|e| self.handle_stdout_error(e))
} }
fn into_stdout_error(&self, error: io::Error) -> Result<(), UiError> { /// Sometimes writing to stdout is not possible, try writing to stderr to
/// signal that failure, otherwise just bail.
fn handle_stdout_error(&self, error: io::Error) -> Result<(), UiError> {
self.write_stderr( self.write_stderr(
&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat(), &[b"abort: ", error.to_string().as_bytes(), b"\n"].concat(),
)?; )?;
Err(UiError::StdoutError(error)) Err(UiError::StdoutError(error))
} }
/// Write bytes to stderr /// Write bytes to stderr
pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stderr = io::stderr(); let mut stderr = self.stderr.lock();
self.write_stream(&mut stderr, bytes) self.write_stream(&mut stderr, bytes)
.or_else(|e| Err(UiError::StderrError(e)))?; .or_else(|e| Err(UiError::StderrError(e)))?;
stderr.flush().or_else(|e| Err(UiError::StderrError(e))) stderr.flush().or_else(|e| Err(UiError::StderrError(e)))
} }
fn write_stream( fn write_stream(
&self, &self,
stream: &mut impl Write, stream: &mut impl Write,
bytes: &[u8], bytes: &[u8],
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
stream.write_all(bytes) stream.write_all(bytes)
} }
} }
/// A buffered stdout writer for faster batch printing operations.
pub struct StdoutBuffer<W: Write> {
buf: io::BufWriter<W>,
}
impl<W: Write> StdoutBuffer<W> {
pub fn new(writer: W) -> Self {
let buf = io::BufWriter::new(writer);
Self { buf }
}
/// Write bytes to stdout buffer
pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> {
self.buf.write_all(bytes).or_else(|e| self.io_err(e))
}
/// Flush bytes to stdout
pub fn flush(&mut self) -> Result<(), UiError> {
self.buf.flush().or_else(|e| self.io_err(e))
}
fn io_err(&self, error: io::Error) -> Result<(), UiError> {
if let ErrorKind::BrokenPipe = error.kind() {
// This makes `| head` work for example
return Ok(());
}
let mut stderr = io::stderr();
stderr
.write_all(
&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat(),
)
.map_err(|e| UiError::StderrError(e))?;
stderr.flush().map_err(|e| UiError::StderrError(e))?;
Err(UiError::StdoutError(error))
}
}