From b6247f409d66c265505e65d13b3de10020e56c08 Mon Sep 17 00:00:00 2001
From: mwojcik <mw@m-labs.hk>
Date: Mon, 29 May 2023 10:03:44 +0800
Subject: [PATCH 1/2] analyzer: fix warnings on standalone

---
 src/runtime/src/analyzer.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/runtime/src/analyzer.rs b/src/runtime/src/analyzer.rs
index 4eb3268..9fcc60a 100644
--- a/src/runtime/src/analyzer.rs
+++ b/src/runtime/src/analyzer.rs
@@ -1,11 +1,13 @@
-use alloc::{rc::Rc, vec::Vec};
+use alloc::rc::Rc;
+#[cfg(has_drtio)]
+use alloc::vec::Vec;
 use core::cell::RefCell;
 
 use libasync::{smoltcp::TcpStream, task};
 use libboard_artiq::drtio_routing;
 use libboard_zynq::{smoltcp::Error, timer::GlobalTimer};
 use libcortex_a9::{cache, mutex::Mutex};
-use log::{debug, error, info, warn};
+use log::{debug, info, warn};
 
 use crate::{pl, proto_async::*};
 
@@ -147,7 +149,7 @@ async fn handle_connection(
             remote.data,
         ),
         Err(e) => {
-            error!("Error getting remote analyzer data: {}", e);
+            warn!("Error getting remote analyzer data: {}", e);
             (
                 Header {
                     total_byte_count: total_byte_count,
-- 
2.42.0


From 5e6dca61a9e208f52e5ed1fa743723acd11bf1e0 Mon Sep 17 00:00:00 2001
From: mwojcik <mw@m-labs.hk>
Date: Mon, 29 May 2023 13:53:28 +0800
Subject: [PATCH 2/2] analyzer: fix overflow behavior

---
 src/satman/src/analyzer.rs | 41 ++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/satman/src/analyzer.rs b/src/satman/src/analyzer.rs
index 8fc7b27..e19adb0 100644
--- a/src/satman/src/analyzer.rs
+++ b/src/satman/src/analyzer.rs
@@ -1,3 +1,4 @@
+use core::cmp::min;
 use libboard_artiq::{drtioaux_proto::ANALYZER_MAX_SIZE, pl::csr};
 use libcortex_a9::cache;
 
@@ -32,8 +33,9 @@ fn disarm() {
 
 pub struct Analyzer {
     // necessary for keeping track of sent data
+    data_len: usize,
     sent_bytes: usize,
-    data_iter: usize,
+    data_pointer: usize
 }
 
 pub struct Header {
@@ -47,20 +49,23 @@ pub struct AnalyzerSliceMeta {
     pub last: bool,
 }
 
+impl Drop for Analyzer {
+    fn drop(&mut self) {
+        disarm();
+    }
+}
+
 impl Analyzer {
     pub fn new() -> Analyzer {
         // create and arm new Analyzer
         arm();
         Analyzer {
+            data_len: 0,
             sent_bytes: 0,
-            data_iter: 0,
+            data_pointer: 0
         }
     }
 
-    fn drop(&mut self) {
-        disarm();
-    }
-
     pub fn get_header(&mut self) -> Header {
         disarm();
 
@@ -68,16 +73,17 @@ impl Analyzer {
         let bus_err = unsafe { csr::rtio_analyzer::dma_bus_error_read() != 0 };
         let total_byte_count = unsafe { csr::rtio_analyzer::dma_byte_count_read() as u64 };
         let wraparound = total_byte_count >= BUFFER_SIZE as u64;
-        self.sent_bytes = if wraparound {
+        self.data_len = if wraparound {
             BUFFER_SIZE
         } else {
             total_byte_count as usize
         };
-        self.data_iter = if wraparound {
+        self.data_pointer = if wraparound {
             (total_byte_count % BUFFER_SIZE as u64) as usize
         } else {
             0
         };
+        self.sent_bytes = 0;
 
         if overflow {
             warn!("overflow occured");
@@ -88,27 +94,24 @@ impl Analyzer {
 
         Header {
             total_byte_count: total_byte_count,
-            sent_bytes: self.sent_bytes as u32,
+            sent_bytes: self.data_len as u32,
             error: overflow | bus_err,
         }
     }
 
     pub fn get_data(&mut self, data_slice: &mut [u8; ANALYZER_MAX_SIZE]) -> AnalyzerSliceMeta {
         let data = unsafe { &BUFFER.data[..] };
-        let i = self.data_iter;
-        let len = if i + ANALYZER_MAX_SIZE < self.sent_bytes {
-            ANALYZER_MAX_SIZE
-        } else {
-            self.sent_bytes - i
-        };
-        let last = i + len == self.sent_bytes;
+        let i = (self.data_pointer + self.sent_bytes) % BUFFER_SIZE;
+        let len = min(ANALYZER_MAX_SIZE, self.data_len - self.sent_bytes);
+        let last = self.sent_bytes + len == self.data_len;
+
         if i + len >= BUFFER_SIZE {
-            data_slice[..len].clone_from_slice(&data[i..BUFFER_SIZE]);
-            data_slice[..len].clone_from_slice(&data[..(i + len) % BUFFER_SIZE]);
+            data_slice[..(BUFFER_SIZE-i)].clone_from_slice(&data[i..BUFFER_SIZE]);
+            data_slice[(BUFFER_SIZE-i)..len].clone_from_slice(&data[..(i + len) % BUFFER_SIZE]);
         } else {
             data_slice[..len].clone_from_slice(&data[i..i + len]);
         }
-        self.data_iter += len;
+        self.sent_bytes += len;
 
         if last {
             arm();
-- 
2.42.0