Remove majority of printing

Author: johnramsden

oxcache/src/bin/evaluationclient.rs

@@ -35,12 +35,12 @@ struct Cli {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let nr_queries = 10000;
+    let nr_queries = 1000000;
     let nr_uuids = 1000;
     let mut queries: Arc<Mutex<Vec<GetRequest>>> = Arc::new(Mutex::new(Vec::new()));
     let args = Cli::parse();
     let counter = Arc::new(AtomicUsize::new(0));
-
+    let step = nr_queries / 10; // 10%
     let mut rng = rng(); // uses fast, thread-local RNG
 
     let mut uuids = Vec::with_capacity(nr_uuids);
@@ -55,7 +55,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 .choose(&mut rng)
                 .expect("uuids vec should not be empty")
                 .clone();
-            
+
             queries.push(GetRequest {
                 key: uuid.to_string(),
                 size: 8192,
@@ -83,7 +83,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             let (read_half, write_half) = split(stream);
             let mut reader = FramedRead::new(read_half, LengthDelimitedCodec::new());
             let mut writer = FramedWrite::new(write_half, LengthDelimitedCodec::new());
-            
+
             loop {
                 let query_num = counter.fetch_add(1, Ordering::Relaxed) + 1;
 
@@ -97,10 +97,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     q = queries.pop().unwrap();
                 }
 
-                if query_num % 100 == 0 {
-                    println!("[t.{}] Query num: {}/{}", c, query_num, nr_queries);
+                if query_num % step == 0 {
+                    let percent = (query_num as f64 / nr_queries as f64) * 100.0;
+                    println!("[t.{}] Query num: {}/{} ({:.0}%)", c, query_num, nr_queries, percent);
                 }
 
+
                 let encoded = bincode::serde::encode_to_vec(
                     Request::Get(q),
                     bincode::config::standard()
@@ -136,6 +138,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     println!("Executed {} queries across {} clients", nr_queries, args.num_clients);
     println!("Total run time: {:.2?}", duration);
-    
+
     Ok(())
 }

oxcache/src/device.rs

@@ -386,9 +386,13 @@ impl Device for BlockInterface {
     fn append(&self, data: Vec<u8>) -> std::io::Result<ChunkLocation> {
         let mtx = self.state.clone();
         let mut state = mtx.lock().unwrap();
+
         let chunk_location = match state.active_zones.remove_chunk_location() {
             Ok(location) => location,
             Err(()) => {
+                eprintln!(
+                    "[append] Failed to allocate chunk: no available space in active zones"
+                );
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::StorageFull,
                     "Cache is full",
@@ -397,16 +401,21 @@ impl Device for BlockInterface {
         };
         drop(state);
 
-        let mut mut_data = vec![0u8; get_aligned_buffer_size(data.len(), self.nvme_config.logical_block_size as usize)];
+        let aligned_size = get_aligned_buffer_size(data.len(), self.nvme_config.logical_block_size as usize);
+        let mut mut_data = vec![0u8; aligned_size];
         mut_data[..data.len()].copy_from_slice(&data[..]);
 
+        let write_addr = get_address_at(
+            chunk_location.zone as u64,
+            chunk_location.index,
+            (self.chunks_per_zone * self.chunk_size) as u64,
+            self.chunk_size as u64,
+        );
+        
+        // println!("[append] writing chunk to {} bytes at addr {}", chunk_location.zone, write_addr);
+
         match nvme::ops::write(
-            get_address_at(
-                chunk_location.zone as u64,
-                chunk_location.index,
-                (self.chunks_per_zone * self.chunk_size) as u64,
-                self.chunk_size as u64,
-            ),
+            write_addr,
             self.nvme_config.fd,
             0,
             self.nvme_config.nsid,
@@ -417,14 +426,26 @@ impl Device for BlockInterface {
                 let mtx = Arc::clone(&self.evict_policy);
                 let mut policy = mtx.lock().unwrap();
                 policy.write_update(ChunkLocation::new(
-                    chunk_location.zone, chunk_location.index, // addr should be in chunks
+                    chunk_location.zone,
+                    chunk_location.index,
                 ));
                 Ok(chunk_location)
-            },
-            Err(err) => Err(err.try_into().unwrap()),
+            }
+            Err(err) => {
+                // eprintln!(
+                //     "[append] nvme::ops::write failed: zone={}, index={}, addr={}, size={} bytes. Error: {:?}",
+                //     chunk_location.zone,
+                //     chunk_location.index,
+                //     write_addr,
+                //     mut_data.len(),
+                //     err
+                // );
+                Err(err.try_into().unwrap())
+            }
         }
     }
 
+
     fn read_into_buffer(
         &self,
         location: ChunkLocation,

oxcache/src/remote.rs

@@ -86,7 +86,7 @@ impl RemoteBackend for S3Backend {
 impl RemoteBackend for EmulatedBackend {
     async fn get(&self, key: &str, offset: usize, size: usize) -> tokio::io::Result<Vec<u8>> {
         // TODO: Implement
-        println!("GET {} {} {}", key, offset, size);
+        // println!("GET {} {} {}", key, offset, size);
         self.gen_random_buffer(key, offset, size)
     }
 }

oxcache/src/server.rs

@@ -163,11 +163,11 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
         let bytes = f.as_ref();
         let msg: Result<(request::Request, usize), DecodeError> =
             bincode::serde::decode_from_slice(bytes, bincode::config::standard());
-        println!("Received: {:?}", msg);
+        // println!("Received: {:?}", msg);
 
         match msg {
             Ok((request, _)) => {
-                println!("Received: {:?}", request);
+                // println!("Received: {:?}", request);
                 match request {
                     request::Request::Get(req) => {
                         if let Err(e) = req.validate(chunk_size) {
@@ -185,12 +185,13 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
                             continue;
                         }
 
-                        println!("Received get request: {:?}", req);
+                        // println!("Received get request: {:?}", req);
                         let chunk: Chunk = req.into();
 
                         cache.get_or_insert_with(
                             chunk.clone(),
                             {
+                                // println!("HIT {:?}", chunk);
                                 let writer = Arc::clone(&writer);
                                 let reader_pool = Arc::clone(&reader_pool);
                                 |location| async move {
@@ -233,6 +234,8 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
                                 }
                             },
                             {
+                                // println!("MISS {:?}", chunk);
+                                
                                 let chunk = chunk.clone();
                                 let writer = Arc::clone(&writer);
                                 let remote = Arc::clone(&remote);