pull request to a new branch

.github/workflows/ci.yaml

@@ -0,0 +1,83 @@
+name: "A+: CI"
+
+permissions:
+  contents: write
+
+on:
+  workflow_dispatch:
+  workflow_call:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  cargo-build:
+    name: Cargo Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Fetch Repository
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Build rlib
+        run: cd bluesim-rlib && cargo b --workspace --all-targets --all-features
+
+      - name: Build rb_link
+        run: cd rb_link && cargo b --workspace --all-targets --all-features
+
+  cargo-fmt:
+    name: Cargo fmt
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Fetch Repository
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          components: rustfmt
+
+      - name: Rustfmt Check rlib
+        run: cd bluesim-rlib && cargo fmt --all --check
+
+      - name: Rustfmt Check rb_link
+        run: cd rb_link && cargo fmt --all --check
+
+  cargo-clippy:
+    name: Cargo clippy
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Fetch Repository
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          components: clippy
+
+      - name: Clippy Check rlib
+        run: cd bluesim-rlib && cargo clippy --workspace --all-targets --all-features -- -Dwarnings 
+
+      - name: Clippy Check rb_link
+        run: cd rb_link && cargo clippy --workspace --all-targets --all-features -- -Dwarnings 
+
+  cargo-test:
+    name: Cargo test
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Fetch Repository
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Cargo test rb_link
+        run: cd rb_link && cargo test
+

.gitignore

@@ -0,0 +1,8 @@
+/examples/AdderPipeline/build/
+/examples/TenStage/build/
+/probe-blue/build/
+**/target/
+**.out**
+command
+log
+Cargo.lock

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 hercule-karuha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,123 @@
-# b2rr2b
+# b2rr2b
+## A Bluesim simulation probe framework.
+
+
+
+This framework includes the following components:
+
+- `/bluesim-rlib` : A Rust library called by the Bluesim program for receiving and sending data.
+- `/probe-blue` : BSV code for the probe, calling Rust functions through the BDPI interface.
+- `/rb_link` :A Rust framework for interacting with probes, capable of getting and sending data.
+
+
+
+### Uasge
+
+First, you need to write BSV code and instantiate `RProbe ` within it.
+
+the example located at: examples/AdderPipeline/AdderPipeline.bsv
+
+```
+import RProbe::*;
+import FIFOF::*;
+
+(* synthesize *)
+module mkAdderPipeline(Empty);
+    FIFOF#(Bit#(32)) f2d <- mkFIFOF;
+    RProbe#(Bit#(32), Bit#(32)) probe <- mkRProbe(0);
+
+    Reg#(Bit#(32)) fetch_times <- mkReg(0);
+    Reg#(Bit#(32)) put_times <- mkReg(0);
+
+
+    rule doGet if (fetch_times < 10);
+        Bit#(32) data = probe.get_data;
+        f2d.enq(data);
+        fetch_times <= fetch_times + 1;
+    endrule
+
+    rule doPut;
+        Bit#(32) data = f2d.first;
+        f2d.deq;
+        probe.put_data(data + 1);
+        put_times <= put_times + 1;
+        if(put_times == 9) begin
+            probe.shut_down_server();
+            $finish;
+        end
+    endrule
+endmodule
+```
+
+You need to link the Rust library file when linking Bluesim.
+
+```
+$ cd bluesim-rilb
+$ cargo build
+$ cd ../examples/AdderPipeline/
+$ bsc -u -sim -bdir build -p .:%/Libraries:../../probe-blue/ -simdir build AdderPipeline.bsv 
+// add the .a file after the link command
+$ bsc -sim -e mkAdderPipeline  -bdir build -simdir build -o adder.out ../../bluesim-rlib/target/debug/libblue.a
+```
+
+Next, write your Rust code for analyzing the data.
+
+the example located at: examples/adder_analysis/
+
+```
+use rb_link::*;
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    let mut server = B2RServer::new_with("/tmp/adder");
+    // the getter used to get data from bluesim
+    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())
+    }
+
+    //start a new thread to receive the data
+    let _ = server.serve();
+
+    thread::sleep(Duration::from_secs(3));
+
+    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[2],
+                msg.message[3]
+            ])
+        );
+    }
+}
+```
+
+Please ensure the rust program runs before the bliuesim
+
+```
+$ cd examples/adder_analysis/
+$ cargo run
+```
+
+
+
+The path for the socket used for communication by default is `/tmp/b2rr2b`.
+
+You can set the desired path by configuring the `B2R_SOCKET` variable.
+
+In another terminal:
+
+```
+B2R_SOCKET=/tmp/adder ./adder.out
+```
+
+
+

bluesim-rlib/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "bluesim-rlib"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["staticlib"]
+name = "blue"
+
+[dependencies]
+rb_link = { path = "../rb_link" }
+bincode = "1.3.3"

bluesim-rlib/src/lib.rs

@@ -0,0 +1,94 @@
+//! The Rust library called by bluesim.
+//! If you want to use RProbe in your bluespec project,
+//! 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;
+
+static mut STREAM: OnceLock<UnixStream> = OnceLock::new();
+
+/// # Safety
+/// This function should not be called by Rust code.
+/// Get data from your rust program.
+/// called by RProbe::get_data()
+#[no_mangle]
+pub unsafe extern "C" fn get(res_ptr: *mut u8, id: u32, _cycles: u32, size: u32) {
+    // println!("send get");
+    // check the ptr is not null
+    if res_ptr.is_null() {
+        panic!("res_ptr is a null pointer!");
+    }
+    if _cycles == u32::MAX {
+        panic!("cycles over flow!");
+    }
+    let mut stream = STREAM.get_or_init(|| {
+        let socket = match env::var("B2R_SOCKET") {
+            Ok(path) => path,
+            Err(_) => "/tmp/b2rr2b".to_string(),
+        };
+        UnixStream::connect(socket).expect("Failed to connect to socket")
+    });
+
+    let get_message = GetPutMessage::Get(id);
+    let serialized = bincode::serialize(&get_message).expect("Serialization failed");
+
+    // The initial 4-byte data specifies the byte count of the message in the u32 format.
+    let msg_size = serialized.len() as MsgSizeType;
+    let mut msg_with_size = Vec::with_capacity(MSG_SIZE_BYTES + serialized.len());
+    msg_with_size.extend_from_slice(&msg_size.to_le_bytes());
+    msg_with_size.extend(serialized.iter());
+    stream
+        .write_all(&msg_with_size)
+        .expect("Failed to write to stream");
+
+    let res_slice = std::slice::from_raw_parts_mut(res_ptr, size as usize);
+    stream
+        .read_exact(res_slice)
+        .expect("Failed to read from stream");
+}
+
+/// # Safety
+/// This function should not be called by Rust code.
+/// Put data to your rust program.
+/// called by RProbe::put_data()
+#[no_mangle]
+pub unsafe extern "C" fn put(id: u32, cycles: u32, data_ptr: *mut u8, size: u32) {
+    // println!("send put");
+    // check the ptr is not null
+    if data_ptr.is_null() {
+        panic!("data_ptr is a null pointer!");
+    }
+    if cycles == u32::MAX {
+        panic!("cycles over flow!");
+    }
+
+    let mut stream = STREAM.get_or_init(|| {
+        let socket = match env::var("B2R_SOCKET") {
+            Ok(path) => path,
+            Err(_) => "/tmp/b2rr2b".to_string(),
+        };
+        UnixStream::connect(socket).expect("Failed to connect to socket")
+    });
+
+    let data_slice = std::slice::from_raw_parts(data_ptr, size as usize);
+    let b2r_message = B2RMessage {
+        id,
+        cycles,
+        message: data_slice.to_vec(),
+    };
+    let put_message = GetPutMessage::Put(b2r_message);
+    let serialized = bincode::serialize(&put_message).expect("Serialization failed");
+
+    // The initial 4-byte data specifies the byte count of the message in the u32 format.
+    let msg_size = serialized.len() as MsgSizeType;
+    let mut msg_with_size = Vec::with_capacity(MSG_SIZE_BYTES + serialized.len());
+    msg_with_size.extend_from_slice(msg_size.to_le_bytes().as_slice());
+    msg_with_size.extend(serialized.iter());
+
+    stream
+        .write_all(&msg_with_size)
+        .expect("Failed to write to stream");
+}

examples/AdderPipeline/AdderPipeline.bsv

@@ -0,0 +1,29 @@
+import RProbe::*;
+import FIFOF::*;
+
+(* synthesize *)
+module mkAdderPipeline(Empty);
+    FIFOF#(Bit#(32)) f2d <- mkFIFOF;
+    RProbe#(Bit#(32), Bit#(32)) probe <- mkRProbe(0);
+
+    Reg#(Bit#(32)) fetch_times <- mkReg(0);
+    Reg#(Bit#(32)) put_times <- mkReg(0);
+
+
+    rule doGet if (fetch_times < 10);
+        Bit#(32) data = probe.get_data;
+        f2d.enq(data);
+        fetch_times <= fetch_times + 1;
+    endrule
+
+    rule doPut;
+        Bit#(32) data = f2d.first;
+        f2d.deq;
+        probe.put_data(data + 1);
+        put_times <= put_times + 1;
+        if(put_times == 9) begin
+            probe.shut_down_server();
+            $finish;
+        end
+    endrule
+endmodule