Remove the generic SerializationSink parameter from Profiler.

Author: michaelwoerister

analyzeme/benches/serialization_bench.rs

@@ -3,26 +3,17 @@
 extern crate test;
 
 use analyzeme::testing_common;
-use measureme::FileSerializationSink;
 
 #[bench]
 fn bench_file_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("file_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,
-        );
+        testing_common::run_serialization_bench("file_serialization_sink_test", 50_000, 8);
     });
 }

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,18 +1,11 @@
 use analyzeme::testing_common::run_end_to_end_serialization_test;
-use measureme::FileSerializationSink;
 
 #[test]
 fn test_file_serialization_sink_1_thread() {
-    run_end_to_end_serialization_test::<FileSerializationSink>(
-        "file_serialization_sink_test_1_thread",
-        1,
-    );
+    run_end_to_end_serialization_test("file_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,
-    );
+    run_end_to_end_serialization_test("file_serialization_sink_test_8_threads", 8);
 }

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/profiler.rs

@@ -1,5 +1,6 @@
 use crate::event_id::EventId;
 use crate::file_header::{write_file_header, FILE_MAGIC_EVENT_STREAM};
+use crate::file_serialization_sink::FileSerializationSink;
 use crate::raw_event::RawEvent;
 use crate::serialization::SerializationSink;
 use crate::stringtable::{SerializableString, StringId, StringTableBuilder};
@@ -24,23 +25,23 @@ impl ProfilerFiles {
     }
 }
 
-pub struct Profiler<S: SerializationSink> {
-    event_sink: Arc<S>,
-    string_table: StringTableBuilder<S>,
+pub struct Profiler {
+    event_sink: Arc<FileSerializationSink>,
+    string_table: StringTableBuilder<FileSerializationSink>,
     start_time: Instant,
 }
 
-impl<S: SerializationSink> Profiler<S> {
-    pub fn new<P: AsRef<Path>>(path_stem: P) -> Result<Profiler<S>, Box<dyn Error + Send + Sync>> {
+impl Profiler {
+    pub fn new<P: AsRef<Path>>(path_stem: P) -> Result<Profiler, Box<dyn Error + Send + Sync>> {
         let paths = ProfilerFiles::new(path_stem.as_ref());
-        let event_sink = Arc::new(S::from_path(&paths.events_file)?);
+        let event_sink = Arc::new(SerializationSink::from_path(&paths.events_file)?);
 
         // The first thing in every file we generate must be the file header.
         write_file_header(&*event_sink, FILE_MAGIC_EVENT_STREAM);
 
         let string_table = StringTableBuilder::new(
-            Arc::new(S::from_path(&paths.string_data_file)?),
-            Arc::new(S::from_path(&paths.string_index_file)?),
+            Arc::new(SerializationSink::from_path(&paths.string_data_file)?),
+            Arc::new(SerializationSink::from_path(&paths.string_index_file)?),
         );
 
         let profiler = Profiler {
@@ -108,7 +109,7 @@ impl<S: SerializationSink> Profiler<S> {
         event_kind: StringId,
         event_id: EventId,
         thread_id: u32,
-    ) -> TimingGuard<'a, S> {
+    ) -> TimingGuard<'a> {
         TimingGuard {
             profiler: self,
             event_id,
@@ -133,15 +134,15 @@ impl<S: SerializationSink> Profiler<S> {
 /// When dropped, this `TimingGuard` will record an "end" event in the
 /// `Profiler` it was created by.
 #[must_use]
-pub struct TimingGuard<'a, S: SerializationSink> {
-    profiler: &'a Profiler<S>,
+pub struct TimingGuard<'a> {
+    profiler: &'a Profiler,
     event_id: EventId,
     event_kind: StringId,
     thread_id: u32,
     start_ns: u64,
 }
 
-impl<'a, S: SerializationSink> Drop for TimingGuard<'a, S> {
+impl<'a> Drop for TimingGuard<'a> {
     #[inline]
     fn drop(&mut self) {
         let raw_event = RawEvent::new_interval(
@@ -156,7 +157,7 @@ impl<'a, S: SerializationSink> Drop for TimingGuard<'a, S> {
     }
 }
 
-impl<'a, S: SerializationSink> TimingGuard<'a, S> {
+impl<'a> TimingGuard<'a> {
     /// This method set a new `event_id` right before actually recording the
     /// event.
     #[inline]