Added tracking for blocked send events

Author: flan

src/protocol/results.rs

@@ -244,6 +244,7 @@ pub struct TcpSendResult {
     pub duration: f32,
 
     pub bytes_sent: u64,
+    pub sends_blocked: u64,
 }
 impl TcpSendResult {
     fn from_json(value:serde_json::Value) -> BoxResult<TcpSendResult> {
@@ -288,12 +289,16 @@ impl IntervalResult for TcpSendResult {
             false => format!("megabytes/second: {:.3}", bytes_per_second / 1_000_000.00),
         };
 
-        format!("----------\n\
+        let mut output = format!("----------\n\
                  TCP send result over {:.2}s | stream: {}\n\
                  bytes: {} | per second: {:.3} | {}",
                 self.duration, self.stream_idx,
                 self.bytes_sent, bytes_per_second, throughput,
-        )
+        );
+        if self.sends_blocked > 0 {
+            output.push_str(&format!("\nstalls due to full send-buffer: {}", self.sends_blocked));
+        }
+        output
     }
 }
 
@@ -383,6 +388,7 @@ pub struct UdpSendResult {
 
     pub bytes_sent: u64,
     pub packets_sent: u64,
+    pub sends_blocked: u64,
 }
 impl UdpSendResult {
     fn from_json(value:serde_json::Value) -> BoxResult<UdpSendResult> {
@@ -427,14 +433,18 @@ impl IntervalResult for UdpSendResult {
             false => format!("megabytes/second: {:.3}", bytes_per_second / 1_000_000.00),
         };
 
-        format!("----------\n\
+        let mut output = format!("----------\n\
                  UDP send result over {:.2}s | stream: {}\n\
                  bytes: {} | per second: {:.3} | {}\n\
                  packets: {} per second: {:.3}",
                 self.duration, self.stream_idx,
                 self.bytes_sent, bytes_per_second, throughput,
                 self.packets_sent, self.packets_sent as f32 / duration_divisor,
-        )
+        );
+        if self.sends_blocked > 0 {
+            output.push_str(&format!("\nstalls due to full send-buffer: {}", self.sends_blocked));
+        }
+        output
     }
 }
 

src/stream/tcp.rs

@@ -517,6 +517,7 @@ pub mod sender {
             let bytes_to_send_per_interval_slice = ((bytes_to_send as f32) * self.send_interval) as i64;
             let mut bytes_to_send_per_interval_slice_remaining = bytes_to_send_per_interval_slice;
 
+            let mut sends_blocked:u64 = 0;
             let mut bytes_sent:u64 = 0;
 
             let peer_addr = match stream.peer_addr() {
@@ -550,12 +551,14 @@ pub mod sender {
                                 duration: elapsed_time.as_secs_f32(),
 
                                 bytes_sent: bytes_sent,
+                                sends_blocked: sends_blocked,
                             })))
                         }
                     },
                     Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => { //send-buffer is full
                         //nothing to do, but avoid burning CPU cycles
                         sleep(BUFFER_FULL_TIMEOUT);
+                        sends_blocked += 1;
                     },
                     Err(e) => {
                         return Some(Err(Box::new(e)));
@@ -587,6 +590,7 @@ pub mod sender {
                     duration: cycle_start.elapsed().as_secs_f32(),
 
                     bytes_sent: bytes_sent,
+                    sends_blocked: sends_blocked,
                 })))
             } else {
                 //indicate that the test is over by dropping the stream

src/stream/udp.rs

@@ -522,6 +522,7 @@ pub mod sender {
             let mut bytes_to_send_per_interval_slice_remaining = bytes_to_send_per_interval_slice;
 
             let mut packets_sent:u64 = 0;
+            let mut sends_blocked:u64 = 0;
             let mut bytes_sent:u64 = 0;
 
             let cycle_start = Instant::now();
@@ -555,12 +556,14 @@ pub mod sender {
 
                                 bytes_sent: bytes_sent,
                                 packets_sent: packets_sent,
+                                sends_blocked: sends_blocked,
                             })))
                         }
                     },
                     Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => { //send-buffer is full
                         //nothing to do, but avoid burning CPU cycles
                         sleep(BUFFER_FULL_TIMEOUT);
+                        sends_blocked += 1;
                         //roll back the packet-ID because nothing was actually emitted
                         self.next_packet_id -= 1;
                     },
@@ -595,6 +598,7 @@ pub mod sender {
 
                     bytes_sent: bytes_sent,
                     packets_sent: packets_sent,
+                    sends_blocked: sends_blocked,
                 })))
             } else {
                 //indicate that the test is over by sending the test ID by itself