compare: Put each group into its own file to be able to run them independently using cargo bench --bench <group>

Author: Mingun

compare/Cargo.toml

@@ -29,5 +29,9 @@ serde_derive = "1.0"
 pretty_assertions = "1.4"
 
 [[bench]]
-name = "bench"
+name = "low-level"
+harness = false
+
+[[bench]]
+name = "serde"
 harness = false

compare/benches/bench.rs renamed to compare/benches/low-level.rs

@@ -2,50 +2,11 @@ use criterion::{self, criterion_group, criterion_main, BenchmarkId, Criterion, T
 use pretty_assertions::assert_eq;
 use quick_xml::events::Event;
 use quick_xml::reader::Reader;
-use serde::Deserialize;
-use serde_xml_rs;
 use std::hint::black_box;
 use xml::reader::{EventReader, XmlEvent};
 
-static RPM_PRIMARY: &str = include_str!("../../tests/documents/rpm_primary.xml");
-static RPM_PRIMARY2: &str = include_str!("../../tests/documents/rpm_primary2.xml");
-static RPM_FILELISTS: &str = include_str!("../../tests/documents/rpm_filelists.xml");
-static RPM_OTHER: &str = include_str!("../../tests/documents/rpm_other.xml");
-static LIBREOFFICE_DOCUMENT: &str = include_str!("../../tests/documents/libreoffice_document.fodt");
-static DOCUMENT: &str = include_str!("../../tests/documents/document.xml");
-static TEST_WRITER_INDENT: &str = include_str!("../../tests/documents/test_writer_indent.xml");
-static SAMPLE_1: &str = include_str!("../../tests/documents/sample_1.xml");
-static LINESCORE: &str = include_str!("../../tests/documents/linescore.xml");
-static SAMPLE_RSS: &str = include_str!("../../tests/documents/sample_rss.xml");
-static SAMPLE_NS: &str = include_str!("../../tests/documents/sample_ns.xml");
-static PLAYERS: &str = include_str!("../../tests/documents/players.xml");
-
-static TEST_FILES: [(&str, &str, usize); 12] = [
-    // long, mix of attributes and text, not much escaping, mix of attribute lengths, some namespaces
-    ("rpm_primary.xml", RPM_PRIMARY, 369),
-    // long, mix of attributes and text, not much escaping, mix of attribute lengths, some namespaces
-    ("rpm_primary2.xml", RPM_PRIMARY2, 116),
-    // long, mostly medium-length text elements, not much escaping
-    ("rpm_filelists.xml", RPM_FILELISTS, 184),
-    // long, mix of attributes and text, lots of escaping (both entity and char literal), long attributes
-    ("rpm_other.xml", RPM_OTHER, 145),
-    // long, mix of attributes and text, not much escaping, lots of non-ascii characters, lots of namespaces
-    ("libreoffice_document.fodt", LIBREOFFICE_DOCUMENT, 659),
-    // medium length, mostly empty tags, a few short attributes per element, no escaping
-    ("document.xml", DOCUMENT, 342),
-    // medium length, lots of namespaces, no escaping
-    ("test_writer_ident.xml", TEST_WRITER_INDENT, 34),
-    // short, mix of attributes and text, lots of escapes
-    ("sample_1.xml", SAMPLE_1, 15),
-    // medium length, lots of attributes, short attributes, few escapes
-    ("linescore.xml", LINESCORE, 11),
-    // short, lots of namespaces, no escapes
-    ("sample_ns.xml", SAMPLE_NS, 11),
-    // long, few attributes, mix of attribute lengths, escapes in text content
-    ("sample_rss.xml", SAMPLE_RSS, 1550),
-    // long, lots of attributes, short attributes, no text, no escapes
-    ("players.xml", PLAYERS, 76),
-];
+mod common;
+use common::*;
 
 // Comparison of low-level APIs from several XML libraries
 fn low_level_comparison(c: &mut Criterion) {
@@ -283,83 +244,5 @@ fn low_level_comparison(c: &mut Criterion) {
     group.finish();
 }
 
-/// Runs benchmarks for several XML libraries using serde deserialization
-#[allow(dead_code)] // We do not use structs
-fn serde_comparison(c: &mut Criterion) {
-    let mut group = c.benchmark_group("serde");
-
-    #[derive(Debug, Deserialize)]
-    struct Rss<E> {
-        channel: Channel<E>,
-    }
-
-    #[derive(Debug, Deserialize)]
-    struct Channel<E> {
-        title: String,
-        #[serde(rename = "item", default = "Vec::new")]
-        items: Vec<Item<E>>,
-    }
-
-    #[derive(Debug, Deserialize)]
-    struct Item<E> {
-        title: String,
-        link: String,
-        #[serde(rename = "pubDate")]
-        pub_date: String,
-        enclosure: Option<E>,
-    }
-
-    #[derive(Debug, Deserialize)]
-    struct Enclosure {
-        #[serde(rename = "@url")]
-        url: String,
-
-        #[serde(rename = "@length")]
-        length: String,
-
-        #[serde(rename = "@type")]
-        typ: String,
-    }
-
-    group.throughput(Throughput::Bytes(SAMPLE_RSS.len() as u64));
-
-    group.bench_with_input(
-        BenchmarkId::new("quick_xml", "sample_rss.xml"),
-        SAMPLE_RSS,
-        |b, input| {
-            b.iter(|| {
-                let rss: Rss<Enclosure> = black_box(quick_xml::de::from_str(input).unwrap());
-                assert_eq!(rss.channel.items.len(), 99);
-            })
-        },
-    );
-
-    /* NOTE: Most parts of deserializer are not implemented yet, so benchmark failed
-    group.bench_with_input(BenchmarkId::new("rapid-xml", "sample_rss.xml"), SAMPLE_RSS, |b, input| {
-        use rapid_xml::de::Deserializer;
-        use rapid_xml::parser::Parser;
-
-        b.iter(|| {
-            let mut r = Parser::new(input.as_bytes());
-            let mut de = Deserializer::new(&mut r).unwrap();
-            let rss = black_box(Rss::deserialize(&mut de).unwrap());
-            assert_eq!(rss.channel.items.len(), 99);
-        });
-    });*/
-
-    group.bench_with_input(
-        BenchmarkId::new("xml_rs", "sample_rss.xml"),
-        SAMPLE_RSS,
-        |b, input| {
-            b.iter(|| {
-                let rss: Rss<Enclosure> = black_box(serde_xml_rs::from_str(input).unwrap());
-                assert_eq!(rss.channel.items.len(), 99);
-            })
-        },
-    );
-
-    group.finish();
-}
-
-criterion_group!(benches, low_level_comparison, serde_comparison);
+criterion_group!(benches, low_level_comparison);
 criterion_main!(benches);

compare/benches/serde.rs

@@ -0,0 +1,89 @@
+use criterion::{self, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use pretty_assertions::assert_eq;
+use serde::Deserialize;
+use serde_xml_rs;
+use std::hint::black_box;
+
+mod common;
+use common::*;
+
+/// Runs benchmarks for several XML libraries using serde deserialization
+#[allow(dead_code)] // We do not use structs
+fn serde_comparison(c: &mut Criterion) {
+    let mut group = c.benchmark_group("serde");
+
+    #[derive(Debug, Deserialize)]
+    struct Rss<E> {
+        channel: Channel<E>,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Channel<E> {
+        title: String,
+        #[serde(rename = "item", default = "Vec::new")]
+        items: Vec<Item<E>>,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Item<E> {
+        title: String,
+        link: String,
+        #[serde(rename = "pubDate")]
+        pub_date: String,
+        enclosure: Option<E>,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Enclosure {
+        #[serde(rename = "@url")]
+        url: String,
+
+        #[serde(rename = "@length")]
+        length: String,
+
+        #[serde(rename = "@type")]
+        typ: String,
+    }
+
+    group.throughput(Throughput::Bytes(SAMPLE_RSS.len() as u64));
+
+    group.bench_with_input(
+        BenchmarkId::new("quick_xml", "sample_rss.xml"),
+        SAMPLE_RSS,
+        |b, input| {
+            b.iter(|| {
+                let rss: Rss<Enclosure> = black_box(quick_xml::de::from_str(input).unwrap());
+                assert_eq!(rss.channel.items.len(), 99);
+            })
+        },
+    );
+
+    /* NOTE: Most parts of deserializer are not implemented yet, so benchmark failed
+    group.bench_with_input(BenchmarkId::new("rapid-xml", "sample_rss.xml"), SAMPLE_RSS, |b, input| {
+        use rapid_xml::de::Deserializer;
+        use rapid_xml::parser::Parser;
+
+        b.iter(|| {
+            let mut r = Parser::new(input.as_bytes());
+            let mut de = Deserializer::new(&mut r).unwrap();
+            let rss = black_box(Rss::deserialize(&mut de).unwrap());
+            assert_eq!(rss.channel.items.len(), 99);
+        });
+    });*/
+
+    group.bench_with_input(
+        BenchmarkId::new("xml_rs", "sample_rss.xml"),
+        SAMPLE_RSS,
+        |b, input| {
+            b.iter(|| {
+                let rss: Rss<Enclosure> = black_box(serde_xml_rs::from_str(input).unwrap());
+                assert_eq!(rss.channel.items.len(), 99);
+            })
+        },
+    );
+
+    group.finish();
+}
+
+criterion_group!(benches, serde_comparison);
+criterion_main!(benches);