Merge pull request #381 from bryandmc/tracing-tools

Begins fixing #179: Add 'tracing' dependency + example tracepoints

glommio/Cargo.toml

@@ -36,12 +36,14 @@ intrusive-collections = "0.9.0"
 lockfree = "0.5"
 membarrier = "0.2.2"
 itertools = "0.10.0"
+tracing = "0.1"
 
 [dev-dependencies]
 futures = "0.3.5"
 fastrand = "1.4.0"
 tokio = { version = "0.3.5", default-features = false, features = ["rt", "macros", "rt-multi-thread", "net", "io-util", "time"] }
 rand = "0.8.0"
+tracing-subscriber = "0.2"
 
 [build-dependencies]
 cc = "1.0.47"

glommio/src/executor/mod.rs

@@ -35,6 +35,7 @@ mod placement;
 
 use latch::{Latch, LatchState};
 pub use placement::{CpuSet, Placement};
+use tracing::trace;
 
 use std::{
     cell::RefCell,
@@ -905,6 +906,7 @@ impl LocalExecutor {
         }
         let p = parking::Parker::new();
         let queues = ExecutorQueues::new(preempt_timer, spin_before_park);
+        trace!(id = notifier.id(), "Creating executor");
         Ok(LocalExecutor {
             queues: Rc::new(RefCell::new(queues)),
             parker: p,
@@ -1993,12 +1995,12 @@ mod test {
         },
         task::Waker,
     };
+    use tracing_subscriber::EnvFilter;
 
     #[test]
     fn create_and_destroy_executor() {
         let mut var = Rc::new(RefCell::new(0));
         let local_ex = LocalExecutor::default();
-
         let varclone = var.clone();
         local_ex.run(async move {
             let mut m = varclone.borrow_mut();

glommio/src/executor/placement/mod.rs

@@ -595,7 +595,7 @@ mod test {
             let cpu_location = max_spreader.next().unwrap();
             counts[cpu_location.cpu] += 1;
         }
-        assert_eq!(1, counts[..3].iter().sum());
+        assert_eq!(1, counts[..3].iter().sum::<i32>());
         assert_eq!(1, counts[3]);
 
         for _ in 2..4 {
@@ -609,7 +609,7 @@ mod test {
             let cpu_location = max_spreader.next().unwrap();
             counts[cpu_location.cpu] += 1;
         }
-        assert_eq!(4, counts[..3].iter().sum());
+        assert_eq!(4, counts[..3].iter().sum::<i32>());
         assert_eq!(2, counts[3]);
 
         for _ in 6..8 {
@@ -665,7 +665,7 @@ mod test {
             }
             counts
                 .chunks(nr_cpu / selected)
-                .for_each(|c| assert_eq!(1, c.iter().sum()));
+                .for_each(|c| assert_eq!(1, c.iter().sum::<i32>()));
             assert_eq!(selected, max_spreader.tree.nr_slots_selected());
             selected_prev = selected;
         }
@@ -689,35 +689,35 @@ mod test {
         let mut max_packer = MaxPacker::from_topology(topology);
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
-        assert_eq!(1, counts[..4].iter().sum());
-        assert_eq!(0, counts[5..].iter().sum());
+        assert_eq!(1, counts[..4].iter().sum::<i32>());
+        assert_eq!(0, counts[5..].iter().sum::<i32>());
 
         for _ in 1..4 {
             let cpu_location = max_packer.next().unwrap();
             counts[cpu_location.cpu] += 1;
         }
-        assert_eq!(4, counts[..4].iter().sum());
-        assert_eq!(0, counts[5..].iter().sum());
+        assert_eq!(4, counts[..4].iter().sum::<i32>());
+        assert_eq!(0, counts[5..].iter().sum::<i32>());
 
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
         assert_eq!(1, counts[6]);
-        assert_eq!(5, counts.iter().sum());
+        assert_eq!(5, counts.iter().sum::<i32>());
 
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
         assert_eq!(1, counts[5]);
-        assert_eq!(6, counts.iter().sum());
+        assert_eq!(6, counts.iter().sum::<i32>());
 
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
         assert_eq!(1, counts[4]);
-        assert_eq!(7, counts.iter().sum());
+        assert_eq!(7, counts.iter().sum::<i32>());
 
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
-        assert_eq!(5, counts[..4].iter().sum());
-        assert_eq!(8, counts.iter().sum());
+        assert_eq!(5, counts[..4].iter().sum::<i32>());
+        assert_eq!(8, counts.iter().sum::<i32>());
 
         for _ in 8..10 * counts.len() {
             let cpu_location = max_packer.next().unwrap();
@@ -746,27 +746,27 @@ mod test {
         let mut max_packer = MaxPacker::from_topology(topology);
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
-        assert_eq!(1, counts[4..].iter().sum());
-        assert_eq!(0, counts[..4].iter().sum());
+        assert_eq!(1, counts[4..].iter().sum::<i32>());
+        assert_eq!(0, counts[..4].iter().sum::<i32>());
 
         for _ in 1..3 {
             let cpu_location = max_packer.next().unwrap();
             counts[cpu_location.cpu] += 1;
         }
-        assert_eq!(3, counts[4..].iter().sum());
-        assert_eq!(0, counts[..4].iter().sum());
+        assert_eq!(3, counts[4..].iter().sum::<i32>());
+        assert_eq!(0, counts[..4].iter().sum::<i32>());
 
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;
-        assert_eq!(4, counts[3..].iter().sum());
-        assert_eq!(0, counts[..3].iter().sum());
+        assert_eq!(4, counts[3..].iter().sum::<i32>());
+        assert_eq!(0, counts[..3].iter().sum::<i32>());
 
         for _ in 4..6 {
             let cpu_location = max_packer.next().unwrap();
             counts[cpu_location.cpu] += 1;
         }
-        assert_eq!(6, counts[1..].iter().sum());
-        assert_eq!(0, counts[..1].iter().sum());
+        assert_eq!(6, counts[1..].iter().sum::<i32>());
+        assert_eq!(0, counts[..1].iter().sum::<i32>());
 
         let cpu_location = max_packer.next().unwrap();
         counts[cpu_location.cpu] += 1;

glommio/src/lib.rs

@@ -679,6 +679,8 @@ pub(crate) mod test_utils {
     use super::*;
     use nix::sys::statfs::*;
     use std::path::{Path, PathBuf};
+    use tracing::{debug, error, info, trace, warn};
+    use tracing_subscriber::EnvFilter;
 
     #[derive(Copy, Clone)]
     pub(crate) enum TestDirectoryKind {
@@ -730,4 +732,18 @@ pub(crate) mod test_utils {
         };
         TestDirectory { path: dir, kind }
     }
+
+    #[test]
+    #[allow(unused_must_use)]
+    fn test_tracing_init() {
+        tracing_subscriber::fmt::fmt()
+            .with_env_filter(EnvFilter::from_env("GLOMMIO_TRACE"))
+            .try_init();
+
+        info!("Started tracing..");
+        debug!("Started tracing..");
+        warn!("Started tracing..");
+        trace!("Started tracing..");
+        error!("Started tracing..");
+    }
 }

glommio/src/sys/sysfs.rs

@@ -537,15 +537,21 @@ mod test {
 
     #[test]
     fn hex_bit_iterator() -> io::Result<()> {
-        assert_eq!(HexBitIterator::from_str("")?.collect::<Vec<_>>(), vec![]);
-        assert_eq!(HexBitIterator::from_str("\n")?.collect::<Vec<_>>(), vec![]);
+        assert_eq!(
+            HexBitIterator::from_str("")?.collect::<Vec<_>>(),
+            Vec::<usize>::new()
+        );
+        assert_eq!(
+            HexBitIterator::from_str("\n")?.collect::<Vec<_>>(),
+            Vec::<usize>::new()
+        );
         assert_eq!(
             HexBitIterator::from_str("00\n")?.collect::<Vec<_>>(),
-            vec![]
+            Vec::<usize>::new()
         );
         assert_eq!(
             HexBitIterator::from_str("0,0\n")?.collect::<Vec<_>>(),
-            vec![]
+            Vec::<usize>::new()
         );
         assert_eq!(
             HexBitIterator::from_str("03")?.collect::<Vec<_>>(),
@@ -622,7 +628,7 @@ mod test {
             .set_used_sized(0)
             .check()?
             .collect::<Vec<_>>();
-        assert_eq!(it, vec![]);
+        assert_eq!(it, Vec::<usize>::new());
 
         let it = RangeIter::new(5)
             .set_end(25)
@@ -683,13 +689,13 @@ mod test {
             ListIterator::from_str("\0")?
                 .collect_ok::<Vec<_>>()
                 .unwrap(),
-            vec![]
+            Vec::<usize>::new()
         );
         assert_eq!(
             ListIterator::from_str("\n")?
                 .collect_ok::<Vec<_>>()
                 .unwrap(),
-            vec![]
+            Vec::<usize>::new()
         );
         assert_eq!(
             ListIterator::from_str("0,8\n")?