feat: add riscv_pmu value

Signed-off-by: Woshiluo Luo <woshiluo.luo@outlook.com>

Author: woshiluo

Cargo.toml

@@ -16,8 +16,6 @@ edition = "2024"
 [dependencies]
 serde = { version = "1.0", default-features = false }
 erased-serde = "0.4"
-
-[dev-dependencies]
 serde_derive = "1.0"
 
 [features]

src/de_mut/matrix.rs

@@ -11,22 +11,40 @@ pub struct MatrixItem<'de, const T: usize> {
 }
 
 impl<'de, const T: usize> Matrix<'de, T> {
-    // Block size in bytes.
+    #[inline(always)]
     pub fn get_block_size() -> usize {
+        // Block size in bytes.
         T * 4
     }
 
+    #[inline(always)]
     pub fn iter(&self) -> MatrixItem<'de, T> {
         MatrixItem {
             offset: 0,
             data: self.data,
         }
     }
+
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.data.len() / T
+    }
+
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.data.len() != 0
+    }
+
+    #[inline(always)]
+    pub fn get(&self, i: usize) -> &'de [u32] {
+        &self.data[i * T..(i + 1) * T]
+    }
 }
 
 impl<'de, const T: usize> Iterator for MatrixItem<'de, T> {
     type Item = &'de [u32];
 
+    #[inline(always)]
     fn next(&mut self) -> Option<Self::Item> {
         if self.data.len() <= self.offset {
             return None;
@@ -51,15 +69,15 @@ impl<'de, const T: usize> Deserialize<'de> for Matrix<'de, T> {
             panic!("unaligned matrix");
         }
         let (prefix, data, suffix) = unsafe { data.align_to::<u32>() };
-        if prefix.len() != 0 || suffix.len() != 0 {
+        if !prefix.is_empty() || !suffix.is_empty() {
             panic!("Not support unaligned data");
         }
 
         Ok(Self { data })
     }
 }
 
-impl<'se, const T: usize> Serialize for Matrix<'se, T> {
+impl<const T: usize> Serialize for Matrix<'_, T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

src/de_mut/node.rs

@@ -302,7 +302,7 @@ impl<'de> PropItem<'de> {
         .unwrap()
     }
 }
-impl<'se> Serialize for NodeItem<'se> {
+impl Serialize for NodeItem<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -311,7 +311,7 @@ impl<'se> Serialize for NodeItem<'se> {
     }
 }
 
-impl<'se> Serialize for PropItem<'se> {
+impl Serialize for PropItem<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -320,7 +320,7 @@ impl<'se> Serialize for PropItem<'se> {
     }
 }
 
-impl<'se> Serialize for Node<'se> {
+impl Serialize for Node<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

src/de_mut/reg.rs

@@ -117,7 +117,7 @@ impl Iterator for RegIter<'_> {
     }
 }
 
-impl<'se> Serialize for Reg<'se> {
+impl Serialize for Reg<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

src/de_mut/str_seq.rs

@@ -91,7 +91,7 @@ impl<'de> Iterator for StrSeqIter<'de> {
     }
 }
 
-impl<'se> Serialize for StrSeq<'se> {
+impl Serialize for StrSeq<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

src/lib.rs

@@ -22,11 +22,11 @@ pub mod de;
 pub mod error;
 pub mod ser;
 pub mod utils;
+pub mod value;
 
 mod common;
 mod de_mut;
 mod tag;
-mod value;
 
 pub use value::compatible::Compatible;
 

src/ser/serializer.rs

@@ -530,7 +530,7 @@ mod tests {
                 hello: 0xdeedbeef,
                 base1: ["Hello", "World!", "Again"],
             };
-            crate::ser::to_dtb(&base, &mut [], &mut buf1).unwrap();
+            crate::ser::to_dtb(&base, &[], &mut buf1).unwrap();
         }
         // TODO: check buf1 buf2
         // println!("{:x?} {:x?}", buf1, buf2);
@@ -560,7 +560,7 @@ mod tests {
                 hello2: 0x11223344,
                 base2: Base1 { hello: "Roger" },
             };
-            crate::ser::to_dtb(&base, &mut [], &mut buf1).unwrap();
+            crate::ser::to_dtb(&base, &[], &mut buf1).unwrap();
         }
         // TODO: check buf1 buf2
         // println!("{:x?} {:x?}", buf1, buf2);

src/value/mod.rs

@@ -1,3 +1,4 @@
 pub mod compatible;
 pub mod cpu;
+pub mod riscv_pmu;
 mod tree;

src/value/riscv_pmu.rs

@@ -0,0 +1,72 @@
+use crate::buildin::Matrix;
+
+use serde_derive::Serialize;
+
+use core::ops::RangeInclusive;
+
+#[repr(transparent)]
+#[derive(Serialize)]
+#[serde(transparent)]
+pub struct EventToMhpmevent<'de>(Matrix<'de, 3>);
+
+#[repr(transparent)]
+#[derive(Serialize)]
+#[serde(transparent)]
+pub struct EventToMhpmcounters<'de>(Matrix<'de, 3>);
+
+#[repr(transparent)]
+#[derive(Serialize)]
+#[serde(transparent)]
+pub struct RawEventToMhpcounters<'de>(Matrix<'de, 5>);
+
+impl EventToMhpmevent<'_> {
+    pub fn get_len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn get_event_id(&self, i: usize) -> u32 {
+        u32::from_be(self.0.get(i)[0])
+    }
+
+    pub fn get_selector_value(&self, i: usize) -> u64 {
+        let current = self.0.get(i);
+        ((u32::from_be(current[1]) as u64) << 32) | (u32::from_be(current[0]) as u64)
+    }
+}
+
+impl EventToMhpmcounters<'_> {
+    pub fn get_len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn get_event_idx_range(&self, i: usize) -> RangeInclusive<u32> {
+        let current = self.0.get(i);
+        u32::from_be(current[0])..=u32::from_be(current[1])
+    }
+
+    pub fn get_counter_bitmap(&self, i: usize) -> u32 {
+        let current = self.0.get(i);
+        u32::from_be(current[2])
+    }
+}
+
+impl RawEventToMhpcounters<'_> {
+    pub fn get_len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn get_event_idx_base(&self, i: usize) -> u64 {
+        let current = self.0.get(i);
+        ((u32::from_be(current[0]) as u64) << 32) | (u32::from_be(current[1]) as u64)
+    }
+
+    pub fn get_event_idx_mask(&self, i: usize) -> u64 {
+        let current = self.0.get(i);
+        ((u32::from_be(current[2]) as u64) << 32) | (u32::from_be(current[3]) as u64)
+    }
+
+    pub fn get_counter_bitmap(&self, i: usize) -> u32 {
+        let current = self.0.get(i);
+        u32::from_be(current[4])
+    }
+}