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,8 +2,6 @@ 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};
 
@@ -283,83 +281,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;
+
+static SAMPLE_RSS: &str = include_str!("../../tests/documents/sample_rss.xml");
+
+/// 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);