Gw/dllm int operation

.gitignore

@@ -18,6 +18,9 @@ build/
 
 doc/figure_gen/*
 
+tools/cost_model/latency/*.png
+tools/cost_model/utilisation/*.png
+
 moduleparamid
 default.svf
 
@@ -61,6 +64,7 @@ ckpts_*
 *.db
 *.db-journal
 co_design/interface/config.toml
+target/
 
 # behavioral simulator
 behavioral_simulator/target

behavioral_simulator/Cargo.toml

@@ -9,6 +9,7 @@ memory =  { path = "lib/memory" }
 ramulator =  { path = "lib/ramulator" }
 buddy =  { path = "lib/buddy" }
 quantize =  { path = "lib/quantize" }
+vector_sram =  { path = "lib/vector_sram" }
 tokio = { version = "1.45.1", features = ["macros", "rt", "rt-multi-thread", "sync"] }
 anyhow = "1"
 async-trait = "0.1.88"
@@ -26,6 +27,7 @@ members = [
     "lib/ramulator",
     "lib/buddy",
     "lib/quantize",
+    "lib/vector_sram",
 ]
 
 [profile.release]

behavioral_simulator/lib/memory/src/lib.rs

@@ -1,6 +1,12 @@
 use std::mem::ManuallyDrop;
 use std::sync::Mutex;
 
+#[derive(Copy, Clone)]
+pub struct Statistics {
+    pub total_bytes_read: u64,
+    pub total_bytes_written: u64,
+}
+
 #[async_trait::async_trait]
 pub trait MemoryTimingModel: Send + Sync {
     /// Read 64-bytes of memory.
@@ -114,3 +120,49 @@ impl<T: MemoryTimingModel, M: MemoryModel> MemoryModel for WithTiming<T, M> {
         self.data.write(addr, bytes).await
     }
 }
+
+// Memory model with utilization statistics
+pub struct WithStats<T> {
+    model: T,
+    statistics: Mutex<Statistics>,
+}
+
+impl<T> WithStats<T> {
+    pub fn new(model: T) -> Self {
+        let stats = Statistics {
+            total_bytes_read: 0,
+            total_bytes_written: 0,
+        };
+        WithStats {
+            model,
+            statistics: Mutex::new(stats),
+        }
+    }
+
+    pub fn model(&self) -> &T {
+        &self.model
+    }
+
+    pub fn statistics(&self) -> Statistics {
+        self.statistics.lock().unwrap().clone()
+    }
+}
+
+#[async_trait::async_trait]
+impl<T: MemoryModel> MemoryModel for WithStats<T> {
+    async fn read(&self, addr: u64) -> [u8; 64] {
+        {
+            let mut guard = self.statistics.lock().unwrap();
+            guard.total_bytes_read += 64;
+        }
+        self.model.read(addr).await
+    }
+
+    async fn write(&self, addr: u64, bytes: [u8; 64]) {
+        {
+            let mut guard = self.statistics.lock().unwrap();
+            guard.total_bytes_written += 64;
+        }
+        self.model.write(addr, bytes).await
+    }
+}

behavioral_simulator/lib/quantize/src/dtype.rs

@@ -162,9 +162,44 @@ fn test_f16() {
     );
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct IntType {
+    pub width: u32,
+}
+
+impl IntType {
+    pub const fn size_in_bits(self) -> u8 {
+        self.width as u8
+    }
+
+    /// Convert f32 to integer bits. Truncates the float to an integer.
+    pub const fn bits_from_f32(self, float: f32) -> u32 {
+        let int_val = float as i32;
+        let mask = if self.width >= 32 {
+            0xFFFFFFFFu32
+        } else {
+            ((1u64 << self.width) - 1) as u32
+        };
+        (int_val as u32) & mask
+    }
+
+    /// Convert integer bits to f32. Interprets bits as unsigned integer.
+    pub const fn convert_bits_to_f32(self, bits: u32) -> f32 {
+        let mask = if self.width >= 32 {
+            0xFFFFFFFFu32
+        } else {
+            ((1u64 << self.width) - 1) as u32
+        };
+        let masked_bits = bits & mask;
+        masked_bits as f32
+    }
+}
+
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DataType {
     Fp(FpType),
+    Int(IntType),
 }
 
 impl From<FpType> for DataType {
@@ -173,22 +208,27 @@ impl From<FpType> for DataType {
     }
 }
 
+
+
 impl DataType {
     pub fn size_in_bits(self) -> u8 {
         match self {
             DataType::Fp(fp_type) => fp_type.size_in_bits(),
+            DataType::Int(int_type) => int_type.size_in_bits(),
         }
     }
 
     pub const fn bits_from_f32(self, float: f32) -> u32 {
         match self {
             DataType::Fp(fp_type) => fp_type.bits_from_f32(float),
+            DataType::Int(int_type) => int_type.bits_from_f32(float),
         }
     }
 
     pub const fn convert_bits_to_f32(self, bits: u32) -> f32 {
         match self {
             DataType::Fp(fp_type) => fp_type.convert_bits_to_f32(bits),
+            DataType::Int(int_type) => int_type.convert_bits_to_f32(bits),
         }
     }
 
@@ -259,6 +299,15 @@ impl MxDataType {
             MxDataType::Mx { elem, .. } => elem,
         }
     }
+
+    /// Returns the size in bits of the element type
+    /// Works for both Plain (FP and Int) and Mx variants
+    pub fn size_in_bits(self) -> u8 {
+        match self {
+            MxDataType::Plain(data_type) => data_type.size_in_bits(),
+            MxDataType::Mx { elem, .. } => elem.size_in_bits(),
+        }
+    }
 }
 
 impl From<FpType> for MxDataType {

behavioral_simulator/lib/quantize/src/lib.rs

@@ -1,5 +1,5 @@
 mod dtype;
 mod tensor;
 
-pub use dtype::{DataType, FpType, MxDataType};
+pub use dtype::{DataType, FpType, IntType, MxDataType};
 pub use tensor::QuantTensor;

behavioral_simulator/lib/runtime/src/time.rs

@@ -106,6 +106,10 @@ impl Instant {
     ///
     /// Effectively means "never".
     pub const ETERNITY: Self = Self(u64::MAX);
+
+    pub const fn to_secs(&self) -> f64 {
+        self.0 as f64 / (1_000_000_000_000_u64 as f64)
+    }
 }
 
 pub trait Deadline {

behavioral_simulator/lib/vector_sram/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "vector_sram"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tokio = { version = "1.45.1", features = ["macros", "rt", "rt-multi-thread", "sync"] }
+quantize = { path = "../quantize" }
+tch = { version = "0.20.0", features = ["download-libtorch"] }
+