Add #[inline] to methods implementing XmlSource

Mingun · Mingun · commit 0b00592cb6c2 · 2024-06-08T16:46:04.000+05:00
All methods called only once or two and inlining them in most cases increases performance
of our benchmarks:

&gt; critcmp master element-parser -t 5
group                                                              element-parser                         master
-----                                                              --------------                         ------
NsReader::read_resolved_event_into/trim_text = true                1.00    384.1±7.53µs        ? ?/sec    1.05    404.0±7.44µs        ? ?/sec
One event/CData                                                    1.00     58.2±1.12ns        ? ?/sec    1.17     68.1±1.35ns        ? ?/sec
One event/Comment                                                  1.00    150.9±2.88ns        ? ?/sec    1.07    161.4±2.79ns        ? ?/sec
decode_and_parse_document_with_namespaces/rpm_filelists.xml        1.00     95.3±1.53µs   115.3 MB/sec    1.07    102.2±1.65µs   107.5 MB/sec
escape_text/escaped_chars_long                                     1.16  1479.3±28.09ns        ? ?/sec    1.00  1275.0±23.98ns        ? ?/sec
escape_text/escaped_chars_short                                    1.00    498.1±8.62ns        ? ?/sec    1.06   526.6±10.80ns        ? ?/sec
escape_text/no_chars_to_escape_long                                1.18  1045.1±19.96ns        ? ?/sec    1.00   887.1±17.00ns        ? ?/sec
escape_text/no_chars_to_escape_short                               1.29     21.0±0.35ns        ? ?/sec    1.00     16.4±0.31ns        ? ?/sec
parse_document_nocopy_with_namespaces/libreoffice_document.fodt    1.00    512.4±9.74µs   106.6 MB/sec    1.07   546.2±10.20µs   100.0 MB/sec
parse_document_nocopy_with_namespaces/rpm_filelists.xml            1.00     86.9±1.49µs   126.4 MB/sec    1.14     99.2±1.74µs   110.7 MB/sec
parse_document_nocopy_with_namespaces/rpm_other.xml                1.00    140.2±2.71µs   157.9 MB/sec    1.06    148.7±2.71µs   148.9 MB/sec
parse_document_nocopy_with_namespaces/rpm_primary.xml              1.00    191.1±3.57µs   106.1 MB/sec    1.09    207.9±3.79µs    97.5 MB/sec
parse_document_nocopy_with_namespaces/rpm_primary2.xml             1.00     62.2±1.20µs   115.2 MB/sec    1.09     67.5±1.28µs   106.2 MB/sec
parse_document_nocopy_with_namespaces/sample_1.xml                 1.00     10.4±0.21µs   106.1 MB/sec    1.07     11.1±0.21µs    99.3 MB/sec
parse_document_nocopy_with_namespaces/sample_ns.xml                1.00      8.5±0.16µs    85.5 MB/sec    1.07      9.0±0.18µs    80.0 MB/sec
parse_document_nocopy_with_namespaces/sample_rss.xml               1.00   784.2±13.53µs   240.5 MB/sec    1.10   859.9±12.82µs   219.3 MB/sec
parse_document_nocopy_with_namespaces/test_writer_ident.xml        1.00     29.0±0.50µs   146.2 MB/sec    1.06     30.8±0.55µs   138.0 MB/sec
read_event/trim_text = false                                       1.00    201.4±4.31µs        ? ?/sec    1.08    218.5±3.98µs        ? ?/sec
read_event/trim_text = true                                        1.00    191.2±3.40µs        ? ?/sec    1.11    211.7±4.11µs        ? ?/sec
diff --git a/src/reader/buffered_reader.rs b/src/reader/buffered_reader.rs
@@ -13,6 +13,7 @@ use crate::reader::{is_whitespace, BangType, Parser, Reader, Span, XmlSource};
 macro_rules! impl_buffered_source {
     ($($lf:lifetime, $reader:tt, $async:ident, $await:ident)?) => {
         #[cfg(not(feature = "encoding"))]
+        #[inline]
         $($async)? fn remove_utf8_bom(&mut self) -> Result<()> {
             use crate::encoding::UTF8_BOM;
 
@@ -31,6 +32,7 @@ macro_rules! impl_buffered_source {
         }
 
         #[cfg(feature = "encoding")]
+        #[inline]
         $($async)? fn detect_encoding(&mut self) -> Result<Option<&'static encoding_rs::Encoding>> {
             loop {
                 break match self $(.$reader)? .fill_buf() $(.$await)? {
@@ -91,6 +93,7 @@ macro_rules! impl_buffered_source {
             Ok((&buf[start..], done))
         }
 
+        #[inline]
         $($async)? fn read<$($lf,)? P: Parser>(
             &mut self,
             buf: &'b mut Vec<u8>,
@@ -134,6 +137,7 @@ macro_rules! impl_buffered_source {
             Err(Error::Syntax(P::eof_error()))
         }
 
+        #[inline]
         $($async)? fn read_bang_element $(<$lf>)? (
             &mut self,
             buf: &'b mut Vec<u8>,
@@ -184,6 +188,7 @@ macro_rules! impl_buffered_source {
             Err(bang_type.to_err())
         }
 
+        #[inline]
         $($async)? fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {
             loop {
                 break match self $(.$reader)? .fill_buf() $(.$await)? {
@@ -203,6 +208,7 @@ macro_rules! impl_buffered_source {
             }
         }
 
+        #[inline]
         $($async)? fn skip_one(&mut self, byte: u8) -> Result<bool> {
             // search byte must be within the ascii range
             debug_assert!(byte.is_ascii());
@@ -216,6 +222,7 @@ macro_rules! impl_buffered_source {
             }
         }
 
+        #[inline]
         $($async)? fn peek_one(&mut self) -> Result<Option<u8>> {
             loop {
                 break match self $(.$reader)? .fill_buf() $(.$await)? {
diff --git a/src/reader/slice_reader.rs b/src/reader/slice_reader.rs
@@ -237,6 +237,7 @@ impl<'a> Reader<&'a [u8]> {
 /// that will be borrowed by events. This implementation provides a zero-copy deserialization
 impl<'a> XmlSource<'a, ()> for &'a [u8] {
     #[cfg(not(feature = "encoding"))]
+    #[inline]
     fn remove_utf8_bom(&mut self) -> Result<()> {
         if self.starts_with(crate::encoding::UTF8_BOM) {
             *self = &self[crate::encoding::UTF8_BOM.len()..];
@@ -245,6 +246,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
     }
 
     #[cfg(feature = "encoding")]
+    #[inline]
     fn detect_encoding(&mut self) -> Result<Option<&'static Encoding>> {
         if let Some((enc, bom_len)) = crate::encoding::detect_encoding(self) {
             *self = &self[bom_len..];
@@ -253,6 +255,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
         Ok(None)
     }
 
+    #[inline]
     fn read_bytes_until(
         &mut self,
         byte: u8,
@@ -275,6 +278,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
         }
     }
 
+    #[inline]
     fn read<P: Parser>(&mut self, _buf: (), position: &mut usize) -> Result<&'a [u8]> {
         let mut parser = P::default();
 
@@ -290,6 +294,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
         Err(Error::Syntax(P::eof_error()))
     }
 
+    #[inline]
     fn read_bang_element(
         &mut self,
         _buf: (),
@@ -311,6 +316,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
         Err(bang_type.to_err())
     }
 
+    #[inline]
     fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {
         let whitespaces = self
             .iter()
@@ -321,6 +327,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
         Ok(())
     }
 
+    #[inline]
     fn skip_one(&mut self, byte: u8) -> Result<bool> {
         // search byte must be within the ascii range
         debug_assert!(byte.is_ascii());
@@ -332,6 +339,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
         }
     }
 
+    #[inline]
     fn peek_one(&mut self) -> Result<Option<u8>> {
         Ok(self.first().copied())
     }

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ use crate::reader::{is_whitespace, BangType, Parser, Reader, Span, XmlSource};`
`13`	`13`	`macro_rules! impl_buffered_source {`
`14`	`14`	`($($lf:lifetime, $reader:tt, $async:ident, $await:ident)?) => {`
`15`	`15`	`#[cfg(not(feature = "encoding"))]`
	`16`	`+ #[inline]`
`16`	`17`	`$($async)? fn remove_utf8_bom(&mut self) -> Result<()> {`
`17`	`18`	`use crate::encoding::UTF8_BOM;`
`18`	`19`
`@@ -31,6 +32,7 @@ macro_rules! impl_buffered_source {`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`#[cfg(feature = "encoding")]`
	`35`	`+ #[inline]`
`34`	`36`	`$($async)? fn detect_encoding(&mut self) -> Result<Option<&'static encoding_rs::Encoding>> {`
`35`	`37`	`loop {`
`36`	`38`	`break match self $(.$reader)? .fill_buf() $(.$await)? {`
`@@ -91,6 +93,7 @@ macro_rules! impl_buffered_source {`
`91`	`93`	`Ok((&buf[start..], done))`
`92`	`94`	`}`
`93`	`95`
	`96`	`+ #[inline]`
`94`	`97`	`$($async)? fn read<$($lf,)? P: Parser>(`
`95`	`98`	`&mut self,`
`96`	`99`	`buf: &'b mut Vec<u8>,`
`@@ -134,6 +137,7 @@ macro_rules! impl_buffered_source {`
`134`	`137`	`Err(Error::Syntax(P::eof_error()))`
`135`	`138`	`}`
`136`	`139`
	`140`	`+ #[inline]`
`137`	`141`	`$($async)? fn read_bang_element $(<$lf>)? (`
`138`	`142`	`&mut self,`
`139`	`143`	`buf: &'b mut Vec<u8>,`
`@@ -184,6 +188,7 @@ macro_rules! impl_buffered_source {`
`184`	`188`	`Err(bang_type.to_err())`
`185`	`189`	`}`
`186`	`190`
	`191`	`+ #[inline]`
`187`	`192`	`$($async)? fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {`
`188`	`193`	`loop {`
`189`	`194`	`break match self $(.$reader)? .fill_buf() $(.$await)? {`
`@@ -203,6 +208,7 @@ macro_rules! impl_buffered_source {`
`203`	`208`	`}`
`204`	`209`	`}`
`205`	`210`
	`211`	`+ #[inline]`
`206`	`212`	`$($async)? fn skip_one(&mut self, byte: u8) -> Result<bool> {`
`207`	`213`	`// search byte must be within the ascii range`
`208`	`214`	`debug_assert!(byte.is_ascii());`
`@@ -216,6 +222,7 @@ macro_rules! impl_buffered_source {`
`216`	`222`	`}`
`217`	`223`	`}`
`218`	`224`
	`225`	`+ #[inline]`
`219`	`226`	`$($async)? fn peek_one(&mut self) -> Result<Option<u8>> {`
`220`	`227`	`loop {`
`221`	`228`	`break match self $(.$reader)? .fill_buf() $(.$await)? {`
Original file line number	Diff line number	Diff line change
`@@ -237,6 +237,7 @@ impl<'a> Reader<&'a [u8]> {`
`237`	`237`	`/// that will be borrowed by events. This implementation provides a zero-copy deserialization`
`238`	`238`	`impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`239`	`239`	`#[cfg(not(feature = "encoding"))]`
	`240`	`+ #[inline]`
`240`	`241`	`fn remove_utf8_bom(&mut self) -> Result<()> {`
`241`	`242`	`if self.starts_with(crate::encoding::UTF8_BOM) {`
`242`	`243`	`*self = &self[crate::encoding::UTF8_BOM.len()..];`
`@@ -245,6 +246,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`245`	`246`	`}`
`246`	`247`
`247`	`248`	`#[cfg(feature = "encoding")]`
	`249`	`+ #[inline]`
`248`	`250`	`fn detect_encoding(&mut self) -> Result<Option<&'static Encoding>> {`
`249`	`251`	`if let Some((enc, bom_len)) = crate::encoding::detect_encoding(self) {`
`250`	`252`	`*self = &self[bom_len..];`
`@@ -253,6 +255,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`253`	`255`	`Ok(None)`
`254`	`256`	`}`
`255`	`257`
	`258`	`+ #[inline]`
`256`	`259`	`fn read_bytes_until(`
`257`	`260`	`&mut self,`
`258`	`261`	`byte: u8,`
`@@ -275,6 +278,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`275`	`278`	`}`
`276`	`279`	`}`
`277`	`280`
	`281`	`+ #[inline]`
`278`	`282`	`fn read<P: Parser>(&mut self, _buf: (), position: &mut usize) -> Result<&'a [u8]> {`
`279`	`283`	`let mut parser = P::default();`
`280`	`284`
`@@ -290,6 +294,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`290`	`294`	`Err(Error::Syntax(P::eof_error()))`
`291`	`295`	`}`
`292`	`296`
	`297`	`+ #[inline]`
`293`	`298`	`fn read_bang_element(`
`294`	`299`	`&mut self,`
`295`	`300`	`_buf: (),`
`@@ -311,6 +316,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`311`	`316`	`Err(bang_type.to_err())`
`312`	`317`	`}`
`313`	`318`
	`319`	`+ #[inline]`
`314`	`320`	`fn skip_whitespace(&mut self, position: &mut usize) -> Result<()> {`
`315`	`321`	`let whitespaces = self`
`316`	`322`	`.iter()`
`@@ -321,6 +327,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`321`	`327`	`Ok(())`
`322`	`328`	`}`
`323`	`329`
	`330`	`+ #[inline]`
`324`	`331`	`fn skip_one(&mut self, byte: u8) -> Result<bool> {`
`325`	`332`	`// search byte must be within the ascii range`
`326`	`333`	`debug_assert!(byte.is_ascii());`
`@@ -332,6 +339,7 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {`
`332`	`339`	`}`
`333`	`340`	`}`
`334`	`341`
	`342`	`+ #[inline]`
`335`	`343`	`fn peek_one(&mut self) -> Result<Option<u8>> {`
`336`	`344`	`Ok(self.first().copied())`
`337`	`345`	`}`