Merge pull request #52 from Atul9/cargo-fmt

Format code using 'cargo fmt'

Author: wesleywiser

crox/src/main.rs

@@ -62,19 +62,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //create an iterator so we can avoid allocating a Vec with every Event for serialization
     let json_event_iterator = std::iter::from_fn(|| {
         while let Some(event) = event_iterator.next() {
-            let event_type =
-                match event.timestamp_kind {
-                    TimestampKind::Start => EventType::Begin,
-                    TimestampKind::End => EventType::End,
-                    //Chrome does not seem to like how many QueryCacheHit events we generate
-                    TimestampKind::Instant => continue,
-                };
+            let event_type = match event.timestamp_kind {
+                TimestampKind::Start => EventType::Begin,
+                TimestampKind::End => EventType::End,
+                // Chrome does not seem to like how many QueryCacheHit events we generate
+                TimestampKind::Instant => continue,
+            };
 
             return Some(Event {
                 name: event.label.clone().into_owned(),
                 category: event.event_kind.clone().into_owned(),
                 event_type,
-                timestamp: event.timestamp.duration_since(first_event_timestamp).unwrap(),
+                timestamp: event
+                    .timestamp
+                    .duration_since(first_event_timestamp)
+                    .unwrap(),
                 process_id: 0,
                 thread_id: event.thread_id,
                 args: None,

measureme/benches/serialization_bench.rs

@@ -1,21 +1,23 @@
-#![feature(test)]
-
-extern crate test;
-
-use measureme::{
-    FileSerializationSink, MmapSerializationSink, testing_common
-};
-
-#[bench]
-fn bench_file_serialization_sink(bencher: &mut test::Bencher) {
-    bencher.iter(|| {
-        testing_common::run_end_to_end_serialization_test::<FileSerializationSink>("file_serialization_sink_test");
-    });
-}
-
-#[bench]
-fn bench_mmap_serialization_sink(bencher: &mut test::Bencher) {
-    bencher.iter(|| {
-        testing_common::run_end_to_end_serialization_test::<MmapSerializationSink>("mmap_serialization_sink_test");
-    });
-}
+#![feature(test)]
+
+extern crate test;
+
+use measureme::{testing_common, FileSerializationSink, MmapSerializationSink};
+
+#[bench]
+fn bench_file_serialization_sink(bencher: &mut test::Bencher) {
+    bencher.iter(|| {
+        testing_common::run_end_to_end_serialization_test::<FileSerializationSink>(
+            "file_serialization_sink_test",
+        );
+    });
+}
+
+#[bench]
+fn bench_mmap_serialization_sink(bencher: &mut test::Bencher) {
+    bencher.iter(|| {
+        testing_common::run_end_to_end_serialization_test::<MmapSerializationSink>(
+            "mmap_serialization_sink_test",
+        );
+    });
+}

measureme/src/file_header.rs

@@ -2,8 +2,8 @@
 //! consists of a 4 byte file magic string and a 4 byte little-endian version
 //! number.
 
-use byteorder::{ByteOrder, LittleEndian};
 use crate::serialization::SerializationSink;
+use byteorder::{ByteOrder, LittleEndian};
 use std::error::Error;
 
 pub const CURRENT_FILE_FORMAT_VERSION: u32 = 0;
@@ -21,28 +21,24 @@ pub fn write_file_header<S: SerializationSink>(s: &S, file_magic: &[u8; 4]) {
     assert_eq!(FILE_HEADER_SIZE, 8);
 
     s.write_atomic(FILE_HEADER_SIZE, |bytes| {
-        bytes[0 .. 4].copy_from_slice(file_magic);
+        bytes[0..4].copy_from_slice(file_magic);
         LittleEndian::write_u32(&mut bytes[4..8], CURRENT_FILE_FORMAT_VERSION);
     });
 }
 
-pub fn read_file_header(
-    bytes: &[u8],
-    expected_magic: &[u8; 4]
-) -> Result<u32, Box<dyn Error>> {
+pub fn read_file_header(bytes: &[u8], expected_magic: &[u8; 4]) -> Result<u32, Box<dyn Error>> {
     // 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);
 
-    let actual_magic = &bytes[0 .. 4];
+    let actual_magic = &bytes[0..4];
 
     if actual_magic != expected_magic {
         // FIXME: The error message should mention the file path in order to be
         //        more useful.
         let msg = format!(
             "Unexpected file magic `{:?}`. Expected `{:?}`",
-            actual_magic,
-            expected_magic,
+            actual_magic, expected_magic,
         );
 
         return Err(From::from(msg));
@@ -52,10 +48,9 @@ pub fn read_file_header(
 }
 
 pub fn strip_file_header(data: &[u8]) -> &[u8] {
-    &data[FILE_HEADER_SIZE ..]
+    &data[FILE_HEADER_SIZE..]
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -69,8 +64,10 @@ mod tests {
 
         let data = data_sink.into_bytes();
 
-        assert_eq!(read_file_header(&data, FILE_MAGIC_EVENT_STREAM).unwrap(),
-                   CURRENT_FILE_FORMAT_VERSION);
+        assert_eq!(
+            read_file_header(&data, FILE_MAGIC_EVENT_STREAM).unwrap(),
+            CURRENT_FILE_FORMAT_VERSION
+        );
     }
 
     #[test]
@@ -97,7 +94,9 @@ mod tests {
         data[5] = 0xFF;
         data[6] = 0xFF;
         data[7] = 0xFF;
-        assert_eq!(read_file_header(&data, FILE_MAGIC_STRINGTABLE_INDEX).unwrap(),
-                   0xFFFF_FFFF);
+        assert_eq!(
+            read_file_header(&data, FILE_MAGIC_STRINGTABLE_INDEX).unwrap(),
+            0xFFFF_FFFF
+        );
     }
 }

measureme/src/lib.rs

@@ -1,8 +1,8 @@
 mod event;
 mod file_header;
-#[cfg(any(not(target_arch="wasm32"), target_os="wasi"))]
+#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 mod file_serialization_sink;
-#[cfg(not(target_arch="wasm32"))]
+#[cfg(not(target_arch = "wasm32"))]
 mod mmap_serialization_sink;
 mod profiler;
 mod profiling_data;
@@ -14,12 +14,12 @@ pub mod rustc;
 pub mod testing_common;
 
 pub use crate::event::Event;
-#[cfg(any(not(target_arch="wasm32"), target_os="wasi"))]
+#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 pub use crate::file_serialization_sink::FileSerializationSink;
-#[cfg(not(target_arch="wasm32"))]
+#[cfg(not(target_arch = "wasm32"))]
 pub use crate::mmap_serialization_sink::MmapSerializationSink;
 pub use crate::profiler::{Profiler, ProfilerFiles};
-pub use crate::profiling_data::{ProfilingData, MatchingEvent};
+pub use crate::profiling_data::{MatchingEvent, ProfilingData};
 pub use crate::raw_event::{RawEvent, Timestamp, TimestampKind};
 pub use crate::serialization::{Addr, SerializationSink};
 pub use crate::stringtable::{

measureme/src/mmap_serialization_sink.rs

@@ -1,8 +1,8 @@
 use crate::serialization::{Addr, SerializationSink};
-use memmap::{MmapMut};
+use memmap::MmapMut;
 use std::error::Error;
-use std::io::{Write, BufWriter};
-use std::fs::{File};
+use std::fs::File;
+use std::io::{BufWriter, Write};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
@@ -60,14 +60,14 @@ impl Drop for MmapSerializationSink {
             Ok(file) => file,
             Err(e) => {
                 eprintln!("Error opening file for writing: {:?}", e);
-                return
+                return;
             }
         };
 
         let mut file = BufWriter::new(file);
 
-        if let Err(e) = file.write_all(&self.mapped_file[0 .. actual_size]) {
+        if let Err(e) = file.write_all(&self.mapped_file[0..actual_size]) {
             eprintln!("Error writing file: {:?}", e);
         }
     }
-}
+}

measureme/src/profiling_data.rs

@@ -1,5 +1,5 @@
-use crate::file_header::FILE_HEADER_SIZE;
 use crate::event::Event;
+use crate::file_header::FILE_HEADER_SIZE;
 use crate::{ProfilerFiles, RawEvent, StringTable, TimestampKind};
 use std::error::Error;
 use std::fs;
@@ -17,7 +17,8 @@ impl ProfilingData {
         let paths = ProfilerFiles::new(path_stem);
 
         let string_data = fs::read(paths.string_data_file).expect("couldn't read string_data file");
-        let index_data = fs::read(paths.string_index_file).expect("couldn't read string_index file");
+        let index_data =
+            fs::read(paths.string_index_file).expect("couldn't read string_index file");
         let event_data = fs::read(paths.events_file).expect("couldn't read events file");
 
         let string_table = StringTable::new(string_data, index_data)?;
@@ -55,8 +56,7 @@ impl<'a> Iterator for ProfilerEventIterator<'a> {
     type Item = Event<'a>;
 
     fn next(&mut self) -> Option<Event<'a>> {
-        let event_start_addr = FILE_HEADER_SIZE +
-            self.curr_event_idx * mem::size_of::<RawEvent>();
+        let event_start_addr = FILE_HEADER_SIZE + self.curr_event_idx * mem::size_of::<RawEvent>();
         let event_end_addr = event_start_addr + mem::size_of::<RawEvent>();
         if event_end_addr > self.data.event_data.len() {
             return None;
@@ -70,7 +70,7 @@ impl<'a> Iterator for ProfilerEventIterator<'a> {
         unsafe {
             let raw_event = std::slice::from_raw_parts_mut(
                 &mut raw_event as *mut RawEvent as *mut u8,
-                std::mem::size_of::<RawEvent>()
+                std::mem::size_of::<RawEvent>(),
             );
             raw_event.copy_from_slice(raw_event_bytes);
         };
@@ -121,21 +121,22 @@ impl<'a> Iterator for MatchingEventsIterator<'a> {
                     let thread_id = event.thread_id as usize;
                     if thread_id >= self.thread_stacks.len() {
                         let growth_size = (thread_id + 1) - self.thread_stacks.len();
-                        self.thread_stacks.append(
-                            &mut vec![vec![]; growth_size]
-                        )
+                        self.thread_stacks.append(&mut vec![vec![]; growth_size])
                     }
 
                     self.thread_stacks[thread_id].push(event);
-                },
+                }
                 TimestampKind::Instant => {
                     return Some(MatchingEvent::Instant(event));
-                },
+                }
                 TimestampKind::End => {
                     let thread_id = event.thread_id as usize;
-                    let previous_event = self.thread_stacks[thread_id].pop().expect("no previous event");
-                    if previous_event.event_kind != event.event_kind ||
-                        previous_event.label != event.label {
+                    let previous_event = self.thread_stacks[thread_id]
+                        .pop()
+                        .expect("no previous event");
+                    if previous_event.event_kind != event.event_kind
+                        || previous_event.label != event.label
+                    {
                         panic!("previous event on thread wasn't the start event");
                     }
 

measureme/src/stringtable.rs

@@ -12,8 +12,10 @@
 //! UTF-8 bytes. The content of a `TAG_STR_REF` is the contents of the entry
 //! it references.
 
-use crate::file_header::{write_file_header, read_file_header, strip_file_header,
-                         FILE_MAGIC_STRINGTABLE_DATA, FILE_MAGIC_STRINGTABLE_INDEX};
+use crate::file_header::{
+    read_file_header, strip_file_header, write_file_header, FILE_MAGIC_STRINGTABLE_DATA,
+    FILE_MAGIC_STRINGTABLE_INDEX,
+};
 use crate::serialization::{Addr, SerializationSink};
 use byteorder::{ByteOrder, LittleEndian};
 use rustc_hash::FxHashMap;
@@ -120,7 +122,6 @@ fn deserialize_index_entry(bytes: &[u8]) -> (StringId, Addr) {
 
 impl<S: SerializationSink> StringTableBuilder<S> {
     pub fn new(data_sink: Arc<S>, index_sink: Arc<S>) -> StringTableBuilder<S> {
-
         // The first thing in every file we generate must be the file header.
         write_file_header(&*data_sink, FILE_MAGIC_STRINGTABLE_DATA);
         write_file_header(&*index_sink, FILE_MAGIC_STRINGTABLE_INDEX);
@@ -239,7 +240,6 @@ pub struct StringTable {
 
 impl<'data> StringTable {
     pub fn new(string_data: Vec<u8>, index_data: Vec<u8>) -> Result<StringTable, Box<dyn Error>> {
-
         let string_data_format = read_file_header(&string_data, FILE_MAGIC_STRINGTABLE_DATA)?;
         let index_data_format = read_file_header(&index_data, FILE_MAGIC_STRINGTABLE_INDEX)?;
 
@@ -248,8 +248,11 @@ impl<'data> StringTable {
         }
 
         if string_data_format != 0 {
-            Err(format!("StringTable file format version '{}' is not supported
-                         by this version of `measureme`.", string_data_format))?;
+            Err(format!(
+                "StringTable file format version '{}' is not supported
+                         by this version of `measureme`.",
+                string_data_format
+            ))?;
         }
 
         assert!(index_data.len() % 8 == 0);