Merge pull request #131 from michaelwoerister/remove_serialization_sink_trait

Remove the SerializationSink trait

Author: wesleywiser

analyzeme/benches/serialization_bench.rs

@@ -3,48 +3,17 @@
 extern crate test;
 
 use analyzeme::testing_common;
-use measureme::{FileSerializationSink, MmapSerializationSink};
 
 #[bench]
-fn bench_file_serialization_sink(bencher: &mut test::Bencher) {
+fn bench_serialization_sink(bencher: &mut test::Bencher) {
     bencher.iter(|| {
-        testing_common::run_serialization_bench::<FileSerializationSink>(
-            "file_serialization_sink_test",
-            500_000,
-            1,
-        );
+        testing_common::run_serialization_bench("serialization_sink_test", 500_000, 1);
     });
 }
 
 #[bench]
-fn bench_mmap_serialization_sink(bencher: &mut test::Bencher) {
+fn bench_serialization_sink_8_threads(bencher: &mut test::Bencher) {
     bencher.iter(|| {
-        testing_common::run_serialization_bench::<MmapSerializationSink>(
-            "mmap_serialization_sink_test",
-            500_000,
-            1,
-        );
-    });
-}
-
-#[bench]
-fn bench_file_serialization_sink_8_threads(bencher: &mut test::Bencher) {
-    bencher.iter(|| {
-        testing_common::run_serialization_bench::<FileSerializationSink>(
-            "file_serialization_sink_test",
-            50_000,
-            8,
-        );
-    });
-}
-
-#[bench]
-fn bench_mmap_serialization_sink_8_threads(bencher: &mut test::Bencher) {
-    bencher.iter(|| {
-        testing_common::run_serialization_bench::<MmapSerializationSink>(
-            "mmap_serialization_sink_test",
-            50_000,
-            8,
-        );
+        testing_common::run_serialization_bench("serialization_sink_test_8_threads", 50_000, 8);
     });
 }

analyzeme/src/profiling_data.rs

@@ -6,7 +6,6 @@ use measureme::file_header::{
     read_file_header, write_file_header, CURRENT_FILE_FORMAT_VERSION, FILE_HEADER_SIZE,
     FILE_MAGIC_EVENT_STREAM,
 };
-use measureme::ByteVecSink;
 use measureme::{EventId, ProfilerFiles, RawEvent, SerializationSink, StringTableBuilder};
 use serde::{Deserialize, Deserializer};
 use std::error::Error;
@@ -200,17 +199,17 @@ impl<'a> DoubleEndedIterator for ProfilerEventIterator<'a> {
 /// implementation might not be efficient, which why it should only be used for
 /// writing tests and other things that are not performance sensitive.
 pub struct ProfilingDataBuilder {
-    event_sink: ByteVecSink,
-    string_table_data_sink: Arc<ByteVecSink>,
-    string_table_index_sink: Arc<ByteVecSink>,
-    string_table: StringTableBuilder<ByteVecSink>,
+    event_sink: SerializationSink,
+    string_table_data_sink: Arc<SerializationSink>,
+    string_table_index_sink: Arc<SerializationSink>,
+    string_table: StringTableBuilder,
 }
 
 impl ProfilingDataBuilder {
     pub fn new() -> ProfilingDataBuilder {
-        let event_sink = ByteVecSink::new();
-        let string_table_data_sink = Arc::new(ByteVecSink::new());
-        let string_table_index_sink = Arc::new(ByteVecSink::new());
+        let event_sink = SerializationSink::new_in_memory();
+        let string_table_data_sink = Arc::new(SerializationSink::new_in_memory());
+        let string_table_index_sink = Arc::new(SerializationSink::new_in_memory());
 
         // The first thing in every file we generate must be the file header.
         write_file_header(&event_sink, FILE_MAGIC_EVENT_STREAM);

analyzeme/src/stringtable.rs

@@ -243,13 +243,13 @@ impl StringTable {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use measureme::{ByteVecSink, StringComponent, StringTableBuilder};
+    use measureme::{SerializationSink, StringComponent, StringTableBuilder};
     use std::sync::Arc;
 
     #[test]
     fn simple_strings() {
-        let data_sink = Arc::new(ByteVecSink::new());
-        let index_sink = Arc::new(ByteVecSink::new());
+        let data_sink = Arc::new(SerializationSink::new_in_memory());
+        let index_sink = Arc::new(SerializationSink::new_in_memory());
 
         let expected_strings = &[
             "abc",
@@ -289,8 +289,8 @@ mod tests {
 
     #[test]
     fn composite_string() {
-        let data_sink = Arc::new(ByteVecSink::new());
-        let index_sink = Arc::new(ByteVecSink::new());
+        let data_sink = Arc::new(SerializationSink::new_in_memory());
+        let index_sink = Arc::new(SerializationSink::new_in_memory());
 
         let expected_strings = &[
             "abc",                  // 0

analyzeme/src/testing_common.rs

@@ -1,6 +1,6 @@
 use crate::timestamp::Timestamp;
 use crate::{Event, ProfilingData};
-use measureme::{EventId, EventIdBuilder, Profiler, SerializationSink, StringId};
+use measureme::{EventId, EventIdBuilder, Profiler, StringId};
 use rustc_hash::FxHashMap;
 use std::borrow::Cow;
 use std::default::Default;
@@ -36,12 +36,12 @@ impl ExpectedEvent {
 }
 
 // Generate some profiling data. This is the part that would run in rustc.
-fn generate_profiling_data<S: SerializationSink>(
+fn generate_profiling_data(
     filestem: &Path,
     num_stacks: usize,
     num_threads: usize,
 ) -> Vec<Event<'static>> {
-    let profiler = Arc::new(Profiler::<S>::new(Path::new(filestem)).unwrap());
+    let profiler = Arc::new(Profiler::new(Path::new(filestem)).unwrap());
 
     let event_id_virtual = EventId::from_label(StringId::new_virtual(42));
     let event_id_builder = EventIdBuilder::new(&profiler);
@@ -187,26 +187,19 @@ fn collect_events_per_thread<'a>(
     per_thread
 }
 
-pub fn run_serialization_bench<S: SerializationSink>(
-    file_name_stem: &str,
-    num_events: usize,
-    num_threads: usize,
-) {
+pub fn run_serialization_bench(file_name_stem: &str, num_events: usize, num_threads: usize) {
     let filestem = mk_filestem(file_name_stem);
-    generate_profiling_data::<S>(&filestem, num_events, num_threads);
+    generate_profiling_data(&filestem, num_events, num_threads);
 }
 
-pub fn run_end_to_end_serialization_test<S: SerializationSink>(
-    file_name_stem: &str,
-    num_threads: usize,
-) {
+pub fn run_end_to_end_serialization_test(file_name_stem: &str, num_threads: usize) {
     let filestem = mk_filestem(file_name_stem);
-    let expected_events = generate_profiling_data::<S>(&filestem, 10_000, num_threads);
+    let expected_events = generate_profiling_data(&filestem, 10_000, num_threads);
     process_profiling_data(&filestem, &expected_events);
 }
 
-fn pseudo_invocation<S: SerializationSink>(
-    profiler: &Profiler<S>,
+fn pseudo_invocation(
+    profiler: &Profiler,
     random: usize,
     thread_id: u32,
     recursions_left: usize,

analyzeme/tests/serialization.rs

@@ -1,34 +1,11 @@
 use analyzeme::testing_common::run_end_to_end_serialization_test;
-use measureme::{FileSerializationSink, MmapSerializationSink};
 
 #[test]
-fn test_file_serialization_sink_1_thread() {
-    run_end_to_end_serialization_test::<FileSerializationSink>(
-        "file_serialization_sink_test_1_thread",
-        1,
-    );
+fn test_serialization_sink_1_thread() {
+    run_end_to_end_serialization_test("serialization_sink_test_1_thread", 1);
 }
 
 #[test]
-fn test_file_serialization_sink_8_threads() {
-    run_end_to_end_serialization_test::<FileSerializationSink>(
-        "file_serialization_sink_test_8_threads",
-        8,
-    );
-}
-
-#[test]
-fn test_mmap_serialization_sink_1_thread() {
-    run_end_to_end_serialization_test::<MmapSerializationSink>(
-        "mmap_serialization_sink_test_1_thread",
-        1,
-    );
-}
-
-#[test]
-fn test_mmap_serialization_sink_8_threads() {
-    run_end_to_end_serialization_test::<MmapSerializationSink>(
-        "mmap_serialization_sink_test_8_threads",
-        8,
-    );
+fn test_serialization_sink_8_threads() {
+    run_end_to_end_serialization_test("serialization_sink_test_8_threads", 8);
 }

measureme/Cargo.toml

@@ -15,6 +15,3 @@ travis-ci = { repository = "rust-lang/measureme" }
 [dependencies]
 rustc-hash = "1.0.1"
 parking_lot = "0.11.0"
-
-[target.'cfg(not(target_arch="wasm32"))'.dependencies]
-memmap = "0.7"

measureme/src/event_id.rs

@@ -1,4 +1,4 @@
-use crate::{Profiler, SerializationSink, StringComponent, StringId};
+use crate::{Profiler, StringComponent, StringId};
 
 /// Event IDs are strings conforming to the following grammar:
 ///
@@ -53,12 +53,12 @@ impl EventId {
     }
 }
 
-pub struct EventIdBuilder<'p, S: SerializationSink> {
-    profiler: &'p Profiler<S>,
+pub struct EventIdBuilder<'p> {
+    profiler: &'p Profiler,
 }
 
-impl<'p, S: SerializationSink> EventIdBuilder<'p, S> {
-    pub fn new(profiler: &Profiler<S>) -> EventIdBuilder<'_, S> {
+impl<'p> EventIdBuilder<'p> {
+    pub fn new(profiler: &Profiler) -> EventIdBuilder<'_> {
         EventIdBuilder { profiler }
     }
 

measureme/src/file_header.rs

@@ -1,8 +1,7 @@
 //! All binary files generated by measureme have a simple file header that
 //! consists of a 4 byte file magic string and a 4 byte little-endian version
 //! number.
-
-use crate::serialization::SerializationSink;
+use crate::SerializationSink;
 use std::convert::TryInto;
 use std::error::Error;
 
@@ -15,7 +14,7 @@ pub const FILE_MAGIC_STRINGTABLE_INDEX: &[u8; 4] = b"MMSI";
 /// rely on this size to be `8`.
 pub const FILE_HEADER_SIZE: usize = 8;
 
-pub fn write_file_header<S: SerializationSink>(s: &S, file_magic: &[u8; 4]) {
+pub fn write_file_header(s: &SerializationSink, file_magic: &[u8; 4]) {
     // The implementation here relies on FILE_HEADER_SIZE to have the value 8.
     // Let's make sure this assumption cannot be violated without being noticed.
     assert_eq!(FILE_HEADER_SIZE, 8);
@@ -54,11 +53,11 @@ pub fn strip_file_header(data: &[u8]) -> &[u8] {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::serialization::ByteVecSink;
+    use crate::SerializationSink;
 
     #[test]
     fn roundtrip() {
-        let data_sink = ByteVecSink::new();
+        let data_sink = SerializationSink::new_in_memory();
 
         write_file_header(&data_sink, FILE_MAGIC_EVENT_STREAM);
 
@@ -72,7 +71,7 @@ mod tests {
 
     #[test]
     fn invalid_magic() {
-        let data_sink = ByteVecSink::new();
+        let data_sink = SerializationSink::new_in_memory();
         write_file_header(&data_sink, FILE_MAGIC_STRINGTABLE_DATA);
         let mut data = data_sink.into_bytes();
 
@@ -83,7 +82,7 @@ mod tests {
 
     #[test]
     fn other_version() {
-        let data_sink = ByteVecSink::new();
+        let data_sink = SerializationSink::new_in_memory();
 
         write_file_header(&data_sink, FILE_MAGIC_STRINGTABLE_INDEX);