Perf: Add BufferedIoRead for ~28.6% faster from_reader parsing

Author: veecore

Cargo.toml

@@ -92,4 +92,4 @@ raw_value = []
 # to be careful around other recursive operations on the parsed result which may
 # overflow the stack after deserialization has completed, including, but not
 # limited to, Display and Debug and Drop impls.
-unbounded_depth = []
+unbounded_depth = []

src/de.rs

@@ -19,7 +19,7 @@ use serde::forward_to_deserialize_any;
 #[cfg(feature = "arbitrary_precision")]
 use crate::number::NumberDeserializer;
 
-pub use crate::read::{Read, SliceRead, StrRead};
+pub use crate::read::{BufferedIoRead, Read, SliceRead, StrRead};
 
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
@@ -2700,3 +2700,82 @@ where
 {
     from_trait(read::StrRead::new(s))
 }
+
+/// Deserializes an instance of type `T` from an I/O stream using an
+/// internal buffer for high performance.
+///
+/// This function is the high-performance counterpart to [`from_reader`].
+///
+/// It wraps the given `io::Read` source in a [`read::BufferedIoRead`]
+/// struct. This specialized reader avoids the per-byte processing overhead
+/// of a simple `io::Read` wrapper (like that used by [`from_reader`])
+/// by reading data in chunks into an internal buffer. It then applies the
+/// same highly-optimized, `memchr`-based parsing logic used for slices
+/// (`SliceRead`) to this internal buffer.
+///
+/// This method is significantly faster (e.g., **~28.6% faster** on a 2.2MB
+/// JSON file) than using `from_reader` even with an external
+/// `std::io::BufReader`, as it entirely eliminates the per-byte
+/// bookkeeping cost during parsing.
+///
+/// ---
+///
+/// ### Buffer Size
+///
+/// This function creates a [`read::BufferedIoRead`] with a **default
+/// internal buffer** (currently 128 bytes).
+///
+/// For most use cases, this default is a good starting point. If you are
+/// parsing from a very slow I/O source or need to control the buffer
+/// size (e.g., to use a larger 8KB buffer) or its allocation, you can
+/// construct a [`read::BufferedIoRead`] manually with your own buffer
+/// and pass it to the generic [`from_trait`] function.
+///
+/// ### Features
+///
+/// This function is only available when the `std` feature is enabled.
+///
+/// # Example
+///
+/// ```
+/// use serde::Deserialize;
+///
+/// use std::error::Error;
+/// use std::fs::File;
+/// use std::io::BufReader;
+/// use std::path::Path;
+///
+/// #[derive(Deserialize, Debug)]
+/// struct User {
+///     fingerprint: String,
+///     location: String,
+/// }
+///
+/// fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<dyn Error>> {
+///     // Open the file in read-only mode.
+///     let file = File::open(path)?;
+///
+///     // Read the JSON contents of the file as an instance of `User` with default buffer.
+///     let u = serde_json::from_reader_buffered(file)?;
+///
+///     // Return the `User`.
+///     Ok(u)
+/// }
+///
+/// fn main() {
+/// # }
+/// # fn fake_main() {
+///     let u = read_user_from_file("test.json").unwrap();
+///     println!("{:#?}", u);
+/// }
+/// ```
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub fn from_reader_buffered<R, T>(rdr: R) -> Result<T>
+where
+    R: crate::io::Read,
+    T: de::DeserializeOwned,
+{
+    let b_rdr: read::BufferedIoRead<R> = read::BufferedIoRead::new(rdr, [0; _]);
+    from_trait(b_rdr)
+}

src/lib.rs

@@ -391,7 +391,7 @@ pub mod __private {
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 #[doc(inline)]
-pub use crate::de::from_reader;
+pub use crate::de::{from_reader, from_reader_buffered};
 #[doc(inline)]
 pub use crate::de::{from_slice, from_str, Deserializer, StreamDeserializer};
 #[doc(inline)]