experiments: setup_l2cache(), add bandwidth tester

experiments/src/main.rs

@@ -15,6 +15,7 @@ use libboard_zynq::{
     clocks::source::{ArmPll, ClockSource, IoPll},
     clocks::Clocks,
     print, println,
+    setup_l2cache,
     sdio::sd_card::SdCard,
     smoltcp::{
         self,
@@ -81,6 +82,8 @@ pub fn main_core0() {
         clocks.cpu_2x(),
         clocks.cpu_1x()
     );
+    info!("Setup L2Cache");
+    setup_l2cache();
 
     let sd = libboard_zynq::sdio::SDIO::sdio0(true);
     // only test SD card if it is inserted
@@ -179,10 +182,10 @@ pub fn main_core0() {
     let eth = zynq::eth::Eth::default(HWADDR.clone());
     println!("Eth on");
 
-    const RX_LEN: usize = 8;
+    const RX_LEN: usize = 4096;
     // Number of transmission buffers (minimum is two because with
     // one, duplicate packet transmission occurs)
-    const TX_LEN: usize = 8;
+    const TX_LEN: usize = 4096;
     let eth = eth.start_rx(RX_LEN);
     let mut eth = eth.start_tx(TX_LEN);
 
@@ -237,18 +240,42 @@ pub fn main_core0() {
         Ok(())
     }
 
-    let counter = alloc::rc::Rc::new(core::cell::RefCell::new(0));
+    // (rx, tx)
+    let stats = alloc::rc::Rc::new(core::cell::RefCell::new((0, 0)));
+    let stats_tx = stats.clone();
     task::spawn(async move {
-        while let Ok(stream) = TcpStream::accept(TCP_PORT, 2048, 2408).await {
+        while let Ok(stream) = TcpStream::accept(TCP_PORT, 0x10_0000, 0x10_0000).await {
-            let counter = counter.clone();
+            let stats_tx = stats_tx.clone();
             task::spawn(async move {
-                *counter.borrow_mut() += 1;
+                let tx_data = (0..=255).take(4096).collect::<alloc::vec::Vec<u8>>();
-                println!("Serving {} connections", *counter.borrow());
+                loop {
-                handle_connection(stream)
+                    // const CHUNK_SIZE: usize = 65536;
-                    .await
+                    // match stream.send((0..=255).cycle().take(CHUNK_SIZE)).await {
-                    .unwrap_or_else(|e| println!("Connection: {:?}", e));
+                    match stream.send_slice(&tx_data[..]).await {
-                *counter.borrow_mut() -= 1;
+                        Ok(len) => stats_tx.borrow_mut().1 += tx_data.len(), //CHUNK_SIZE,
-                println!("Now serving {} connections", *counter.borrow());
+                        Err(e) => {
+                            warn!("tx: {:?}", e);
+                            break
+                        }
+                    }
+                }
+            });
+        }
+    });
+    let stats_rx = stats.clone();
+    task::spawn(async move {
+        while let Ok(stream) = TcpStream::accept(TCP_PORT+1, 0x10_0000, 0x10_0000).await {
+            let stats_rx = stats_rx.clone();
+            task::spawn(async move {
+                loop {
+                    match stream.recv(|buf| Poll::Ready((buf.len(), buf.len()))).await {
+                        Ok(len) => stats_rx.borrow_mut().0 += len,
+                        Err(e) => {
+                            warn!("rx: {:?}", e);
+                            break
+                        }
+                    }
+                }
             });
         }
     });
@@ -261,7 +288,13 @@ pub fn main_core0() {
             let timestamp = timer.get_us();
             let seconds = timestamp / 1_000_000;
             let micros = timestamp % 1_000_000;
-            info!("time: {:6}.{:06}s", seconds, micros);
+            let (rx, tx) = {
+                let mut stats = stats.borrow_mut();
+                let result = *stats;
+                *stats = (0, 0);
+                result
+            };
+            info!("time: {:6}.{:06}s, rx: {}k/s, tx: {}k/s", seconds, micros, rx / 1024, tx / 1024);
         }
     });