fixup

Author: Frando

examples/compute.rs

@@ -267,33 +267,33 @@ async fn local() -> anyhow::Result<()> {
     let api = ComputeActor::local();
 
     // Test Sqr
-    let request = api.sqr(5).await?;
-    println!("Local: 5^2 = {}", request.await?);
+    let rx = api.sqr(5).await?;
+    println!("Local: 5^2 = {}", rx.await?);
 
     // Test Sum
-    let (reply, request) = api.sum().await?;
-    reply.send(1).await?;
-    reply.send(2).await?;
-    reply.send(3).await?;
-    drop(reply);
-    println!("Local: sum of [1, 2, 3] = {}", request.await?);
+    let (tx, rx) = api.sum().await?;
+    tx.send(1).await?;
+    tx.send(2).await?;
+    tx.send(3).await?;
+    drop(tx);
+    println!("Local: sum of [1, 2, 3] = {}", rx.await?);
 
     // Test Fibonacci
-    let mut request = api.fibonacci(10).await?;
+    let mut rx = api.fibonacci(10).await?;
     print!("Local: Fibonacci up to 10 = ");
-    while let Some(num) = request.recv().await? {
+    while let Some(num) = rx.recv().await? {
         print!("{} ", num);
     }
     println!();
 
     // Test Multiply
-    let (in_reply, mut out_request) = api.multiply(3).await?;
-    in_reply.send(2).await?;
-    in_reply.send(4).await?;
-    in_reply.send(6).await?;
-    drop(in_reply);
+    let (in_tx, mut out_rx) = api.multiply(3).await?;
+    in_tx.send(2).await?;
+    in_tx.send(4).await?;
+    in_tx.send(6).await?;
+    drop(in_tx);
     print!("Local: 3 * [2, 4, 6] = ");
-    while let Some(num) = out_request.recv().await? {
+    while let Some(num) = out_rx.recv().await? {
         print!("{} ", num);
     }
     println!();
@@ -318,33 +318,33 @@ async fn remote() -> anyhow::Result<()> {
     let (api, handle) = remote_api()?;
 
     // Test Sqr
-    let request = api.sqr(4).await?;
-    println!("Remote: 4^2 = {}", request.await?);
+    let rx = api.sqr(4).await?;
+    println!("Remote: 4^2 = {}", rx.await?);
 
     // Test Sum
-    let (reply, request) = api.sum().await?;
-    reply.send(4).await?;
-    reply.send(5).await?;
-    reply.send(6).await?;
-    drop(reply);
-    println!("Remote: sum of [4, 5, 6] = {}", request.await?);
+    let (tx, rx) = api.sum().await?;
+    tx.send(4).await?;
+    tx.send(5).await?;
+    tx.send(6).await?;
+    drop(tx);
+    println!("Remote: sum of [4, 5, 6] = {}", rx.await?);
 
     // Test Fibonacci
-    let mut request = api.fibonacci(20).await?;
+    let mut rx = api.fibonacci(20).await?;
     print!("Remote: Fibonacci up to 20 = ");
-    while let Some(num) = request.recv().await? {
+    while let Some(num) = rx.recv().await? {
         print!("{} ", num);
     }
     println!();
 
     // Test Multiply
-    let (in_reply, mut out_request) = api.multiply(5).await?;
-    in_reply.send(1).await?;
-    in_reply.send(2).await?;
-    in_reply.send(3).await?;
-    drop(in_reply);
+    let (in_tx, mut out_rx) = api.multiply(5).await?;
+    in_tx.send(1).await?;
+    in_tx.send(2).await?;
+    in_tx.send(3).await?;
+    drop(in_tx);
     print!("Remote: 5 * [1, 2, 3] = ");
-    while let Some(num) = out_request.recv().await? {
+    while let Some(num) = out_rx.recv().await? {
         print!("{} ", num);
     }
     println!();
@@ -433,12 +433,12 @@ fn clear_line() -> io::Result<()> {
 // Simple benchmark sending oneshot senders via an mpsc channel
 pub async fn reference_bench(n: u64) -> anyhow::Result<()> {
     // Create an mpsc channel to send oneshot senders
-    let (reply, mut request) = tokio::sync::mpsc::channel::<tokio::sync::oneshot::Sender<u64>>(32);
+    let (tx, mut rx) = tokio::sync::mpsc::channel::<tokio::sync::oneshot::Sender<u64>>(32);
 
     // Spawn a task to respond to all oneshot senders
     tokio::spawn(async move {
-        while let Some(sender) = request.recv().await {
-            // Immediately send a fixed reply (42) back through the oneshot sender
+        while let Some(sender) = rx.recv().await {
+            // Immediately send a fixed response (42) back through the oneshot sender
             sender.send(42).ok();
         }
         Ok::<(), io::Error>(())
@@ -450,15 +450,15 @@ pub async fn reference_bench(n: u64) -> anyhow::Result<()> {
         let t0 = std::time::Instant::now();
         for i in 0..n {
             let (send, recv) = tokio::sync::oneshot::channel();
-            reply.send(send).await?;
+            tx.send(send).await?;
             sum += recv.await?;
             if i % 10000 == 0 {
                 print!(".");
                 io::stdout().flush()?;
             }
         }
         let rps = ((n as f64) / t0.elapsed().as_secs_f64()).round() as u64;
-        assert_eq!(sum, 42 * n); // Each reply is 42
+        assert_eq!(sum, 42 * n); // Each response is 42
         clear_line()?;
         println!("Reference seq {} rps", rps.separate_with_underscores());
     }
@@ -468,13 +468,13 @@ pub async fn reference_bench(n: u64) -> anyhow::Result<()> {
         let t0 = std::time::Instant::now();
         let reqs = n0_future::stream::iter((0..n).map(|_| async {
             let (send, recv) = tokio::sync::oneshot::channel();
-            reply.send(send).await?;
+            tx.send(send).await?;
             anyhow::Ok(recv.await?)
         }));
         let resp: Vec<_> = reqs.buffered_unordered(32).try_collect().await?;
         let sum = resp.into_iter().sum::<u64>();
         let rps = ((n as f64) / t0.elapsed().as_secs_f64()).round() as u64;
-        assert_eq!(sum, 42 * n); // Each reply is 42
+        assert_eq!(sum, 42 * n); // Each response is 42
         clear_line()?;
         println!("Reference par {} rps", rps.separate_with_underscores());
     }