pull request to a new branch

bluesim-rlib/src/lib.rs

@@ -3,6 +3,7 @@
 //! please compile this crate into an .a file and then link it to your bluesim executable.
 #![warn(clippy::unwrap_used)]
 use rb_link::{B2RMessage, GetPutMessage, MsgSizeType, MSG_SIZE_BYTES};
+use std::env;
 use std::io::{Read, Write};
 use std::os::unix::net::UnixStream;
 use std::sync::OnceLock;
@@ -24,7 +25,11 @@ pub unsafe extern "C" fn get(res_ptr: *mut u8, id: u32, _cycles: u32, size: u32)
         panic!("cycles over flow!");
     }
     let mut stream = STREAM.get_or_init(|| {
-        UnixStream::connect(String::from("/tmp/b2rr2b")).expect("Failed to connect to socket")
+        let socket = match env::var("B2R_SOCKET") {
+            Ok(path) => path,
+            Err(_) => "/tmp/b2rr2b".to_string(),
+        };
+        UnixStream::connect(String::from(socket)).expect("Failed to connect to socket")
     });
 
     let get_message = GetPutMessage::Get(id);
@@ -61,7 +66,11 @@ pub unsafe extern "C" fn put(id: u32, cycles: u32, data_ptr: *mut u8, size: u32)
     }
 
     let mut stream = STREAM.get_or_init(|| {
-        UnixStream::connect(String::from("/tmp/b2rr2b")).expect("Failed to connect to socket")
+        let socket = match env::var("B2R_SOCKET") {
+            Ok(path) => path,
+            Err(_) => "/tmp/b2rr2b".to_string(),
+        };
+        UnixStream::connect(String::from(socket)).expect("Failed to connect to socket")
     });
 
     let data_slice = std::slice::from_raw_parts(data_ptr, size as usize);

examples/TenStage/TenStage.bsv

@@ -6,9 +6,11 @@ import RProbe::*;
 import FIFOF::*;
 import Vector::*;
 
+typedef 10 RULE_ID_START;
+
 (* synthesize *)
 module mkAdderPipeline(Empty);
-    function gen_fire_probes(Integer x) = mkRProbe(fromInteger(x + 10));
+    function gen_fire_probes(Integer x) = mkRProbe(fromInteger(x + valueOf(RULE_ID_START)));
 
     Vector#(9, FIFOF#(Bit#(32))) fifos <- replicateM(mkSizedFIFOF(5));
 
@@ -19,6 +21,8 @@ module mkAdderPipeline(Empty);
 
     RProbe#(Bit#(32), Bit#(32)) recv_probe <- mkRProbe(20);
 
+    Bit#(32) stuck_num = 32'h5c;
+
     rule stage1;
         Bit#(32) data = recv_probe.get_data;
         fire_probes[0].put_data(True);
@@ -48,7 +52,7 @@ module mkAdderPipeline(Empty);
 
     rule stage5;
         Bit#(32) data = fifos[3].first;
-        if(data != 32'h5c) begin
+        if(data != stuck_num) begin
             fifos[3].deq;
             fire_probes[4].put_data(True);
             fifos[4].enq(data + 1);

examples/adder-pipeline/AdderPipeline.bsv

@@ -22,6 +22,7 @@ module mkAdderPipeline(Empty);
         probe.put_data(data + 1);
         put_times <= put_times + 1;
         if(put_times == 9) begin
+            probe.shut_down_server();
             $finish;
         end
     endrule

examples/pipeline-analyzer/src/main.rs

@@ -3,7 +3,8 @@ use std::thread;
 use std::time::Duration;
 
 fn main() {
-    let mut server = B2RServer::new();
+    let mut server = B2RServer::new_with("/tmp/adder");
+    let mut id_getter = IDGetter::new(&server);
     for i in 0..10 {
         let num: u32 = i;
         server.put(0, num.to_le_bytes().to_vec())
@@ -13,15 +14,15 @@ fn main() {
 
     thread::sleep(Duration::from_secs(3));
 
-    let msg_vec = server.get_id_all(0);
+    let msg_vec = id_getter.get_id_all(0);
     for msg in msg_vec {
         println!(
             "get from blue id:{}, cycle:{}, data:{}",
             msg.id,
             msg.cycles,
             u32::from_le_bytes([
                 msg.message[0],
-                msg.message[1],
+                msg.message[1], 
                 msg.message[2],
                 msg.message[3]
             ])

examples/ten_stage_analysis/src/main.rs

@@ -5,17 +5,20 @@ use std::time::Duration;
 fn main() {
     let input_data: Vec<u32> = (1..200).collect();
 
-    let mut server = B2RServer::new();
+    let mut server = B2RServer::new_with("/tmp/ten_stage");
+    let mut pipe_getter = PipeLineGetter::new(&server);
 
-    for i in input_data {
-        server.put(20, i.to_le_bytes().to_vec())
-    }
-    // mark the probe as fifo or fired
     for i in 0..9 {
-        server.give_type(ProbeType::Fifo, i as u32);
+        let id: u32 = i;
+        pipe_getter.add_fifo_probe(id);
     }
     for i in 10..19 {
-        server.give_type(ProbeType::Fired, i as u32);
+        let id: u32 = i;
+        pipe_getter.add_rule_probe(id);
+    }
+
+    for i in input_data {
+        server.put(20, i.to_le_bytes().to_vec())
     }
 
     let handlle = server.serve();
@@ -24,7 +27,7 @@ fn main() {
 
     let mut fired: u32 = 0;
     loop {
-        let state = server.get_pipeline_state();
+        let state = pipe_getter.get_pipeline_state();
         if state.fire_rules.len() as u32 > fired {
             fired = state.fire_rules.len() as u32;
         } else if state.empty_fifos.len() + state.full_fifos.len() == 9 { // if all fifos is empty or full the pipeline is stuck
@@ -39,7 +42,7 @@ fn main() {
             }
             print!("\nfired rules:");
             for id in state.fire_rules {
-                print!(" {} ", id)
+                print!(" {}  ", id)
             }
             print!("\n");
             break;

probe-blue/RProbe.bsv

@@ -9,9 +9,13 @@ import FIFOF::*;
 interface RProbe#(type get_t, type put_t);
     method get_t get_data();
     method Action put_data(put_t data);
+    // should be called when there is no more message to send
+    method Action shut_down_server();
 endinterface
 
 module mkRProbe#(Bit#(WORD_WIDTH) id)(RProbe#(get_t, put_t)) provisos(Bits#(get_t, wid_get), Bits#(put_t, wid_put));
+    Bit#(WORD_WIDTH) shut_down_id = 32'hFFFFFFFF;
+    Bit#(WORD_WIDTH) shut_down_msg = 32'h0;
     Bit#(WORD_WIDTH) get_size = fromInteger(valueOf(TDiv#(wid_get, BYTE_WIDTH)));
     Bit#(WORD_WIDTH) put_size = fromInteger(valueOf(TDiv#(wid_put, BYTE_WIDTH)));
 
@@ -30,6 +34,10 @@ module mkRProbe#(Bit#(WORD_WIDTH) id)(RProbe#(get_t, put_t)) provisos(Bits#(get_
         let bvec = pack(data);
         put(id, cycles, bvec, put_size);
     endmethod
+
+    method Action shut_down_server();
+        put(shut_down_id, cycles, shut_down_msg, put_size);
+    endmethod
 endmodule
 
 module mkFIFOFProbe#(Bit#(WORD_WIDTH) id, FIFOF#(t) fifo)(Empty);

rb_link/src/config.rs

@@ -1,2 +1,3 @@
 pub type MsgSizeType = u32;
 pub const MSG_SIZE_BYTES: usize = std::mem::size_of::<MsgSizeType>();
+pub const SHUT_DOWN_ID:u32 = 0xFFFFFFFF;

rb_link/src/lib.rs

@@ -3,7 +3,7 @@
 
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
-mod test;
+mod  test;
 
 mod config;
 mod server;

rb_link/src/server/mod.rs

@@ -18,7 +18,7 @@ pub enum GetPutMessage {
 
 #[derive(Serialize, Deserialize)]
 struct R2BMessage {
-    id: u32, 
+    id: u32,
     message: Vec<u8>,
 }
 
@@ -36,41 +36,50 @@ pub struct B2RMessage {
 /// A server for interacting with Bluesim.
 /// Cache bidirectional data and send data upon receiving requests.
 pub struct B2RServer {
+    socket_path: String,
     b2r_cache: Arc<Mutex<HashMap<u32, VecDeque<B2RMessage>>>>,
     r2b_cache: Arc<Mutex<HashMap<u32, VecDeque<R2BMessage>>>>,
 }
 
-
-
-
 impl Default for B2RServer {
     fn default() -> Self {
         Self::new()
     }
 }
 
 impl B2RServer {
-    /// make a new server
+    /// make a new server with socket: /tmp/b2rr2b
     pub fn new() -> Self {
         B2RServer {
+            socket_path: "/tmp/b2rr2b".to_string(),
             b2r_cache: Arc::new(Mutex::new(HashMap::new())),
             r2b_cache: Arc::new(Mutex::new(HashMap::new())),
         }
     }
 
-
+    /// make a new server with a socket path
+    /// you need to specify the B2R_SOCKET environment variable when start the bluesim
+    pub fn new_with(path: &str) -> Self {
+        B2RServer {
+            socket_path: path.to_string(),
+            b2r_cache: Arc::new(Mutex::new(HashMap::new())),
+            r2b_cache: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
 
     /// Start a thread to run the server.
     /// Create a UnixListener at "/tmp/b2rr2b".
     /// Return the JoinHandle of that thread.
     /// This function needs to be called before running your Bluesim program.
+    /// the server thread returns when bluesim called shut_down_server()
     pub fn serve(&mut self) -> JoinHandle<()> {
         // let probe_infos = self.probe_infos.clone();
         let b2r_cache = self.b2r_cache.clone();
         let r2b_cache = self.r2b_cache.clone();
+        let socket_path = self.socket_path.clone();
         thread::spawn(move || {
-            let _ = fs::remove_file("/tmp/b2rr2b");
-            let listener = UnixListener::bind("/tmp/b2rr2b").expect("Failed to bind Unix listener");
+            let _ = fs::remove_file(socket_path.as_str());
+            let listener = UnixListener::bind(socket_path).expect("Failed to bind Unix listener");
             let mut stream = match listener.incoming().next() {
                 Some(stream_res) => stream_res.expect("Fail to connect to bluesim"),
                 None => panic!("listener returns a None"),
@@ -96,6 +105,10 @@ impl B2RServer {
                     }
                     GetPutMessage::Put(b2r_message) => {
                         // println!("receive put to id {}", b2r_message.id);
+                        // return if reveive message with SHUT_DOWN_ID
+                        if b2r_message.id == SHUT_DOWN_ID {
+                            return;
+                        }
                         let mut b2r_cache = b2r_cache.lock().expect("Fail to lock b2r_cache");
                         let queue = b2r_cache.entry(b2r_message.id).or_default();
                         queue.push_back(b2r_message);
@@ -105,7 +118,6 @@ impl B2RServer {
         })
     }
 
-
     /// Send a message to the probe with ID "id".
     /// Please ensure that message.len() == ceil(get_t_width/8),
     /// where get_t_width is the width of get_t defined in your BSV code.
@@ -115,7 +127,6 @@ impl B2RServer {
         let queue = r2b_cache.entry(id).or_default();
         queue.push_back(r2b_message);
     }
-
 }
 
 fn get_msg_size(bytes: Vec<u8>) -> u32 {
@@ -124,6 +135,8 @@ fn get_msg_size(bytes: Vec<u8>) -> u32 {
 
 fn receive_getput(stream: &mut UnixStream) -> Result<GetPutMessage, Box<bincode::ErrorKind>> {
     // println!("connect comeing");
+    // the first MSG_SIZE_BYTES bytes is the size of message
+    // use to initialize the buffer
     let mut sz_buf: Vec<u8> = vec![0; MSG_SIZE_BYTES];
     stream
         .read_exact(&mut sz_buf)