feat: add riscv_pmu test

refactor: remove serde_dervier

Signed-off-by: Woshiluo Luo <[email protected]>

Author: woshiluo

Cargo.toml

@@ -14,8 +14,7 @@ edition = "2024"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0", default-features = false }
-serde_derive = "1.0"
+serde = { version = "1.0", default-features = false, features = ["derive"] }
 erased-serde = { version = "0.4", optional = true }
 
 [features]

examples/hifive-unmatched-a00.rs

@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use alloc::collections::BTreeMap;
-use serde_derive::Deserialize;
+use serde::Deserialize;
 use serde_device_tree::Compatible;
 
 #[derive(Debug, Deserialize)]

examples/qemu-virt.rs

@@ -1,8 +1,7 @@
 //! 这是一个 `from_raw_mut` 反序列化设备树的示例。不需要 `alloc`。
 // extern crate alloc;
 
-// 在实际使用中，将这里的 `serde_derive::Deserialize` 改为 `serde::Deserialize`。
-use serde_derive::Deserialize;
+use serde::Deserialize;
 
 // - `DtbPtr`: 验证设备树首部正确性，后续也可借助这个类型传递设备树，多次解析不必重复验证。
 // - `Dtb`: 管理反序列化出的类型生命周期。

examples/serialize.rs

@@ -1,4 +1,4 @@
-use serde_derive::Serialize;
+use serde::Serialize;
 use std::io::prelude::*;
 
 const MAX_SIZE: usize = 256 + 32;

src/de.rs

@@ -42,7 +42,7 @@ use serde::de;
 /// # });
 /// # aligned_data.data[..BUFFER_SIZE].clone_from_slice(RAW_DEVICE_TREE);
 /// # let fdt_ptr = aligned_data.data.as_ptr();
-/// use serde_derive::Deserialize;
+/// use serde::Deserialize;
 ///
 /// #[derive(Debug, Deserialize)]
 /// struct Tree<'a> {
@@ -516,7 +516,7 @@ mod tests {
     #[cfg(feature = "alloc")]
     use alloc::format;
     #[cfg(any(feature = "std", feature = "alloc"))]
-    use serde_derive::Deserialize;
+    use serde::Deserialize;
     #[cfg(feature = "std")]
     use std::format;
 

src/de_mut/matrix.rs

@@ -55,7 +55,7 @@ impl<'de, const T: usize> Iterator for MatrixItem<'de, T> {
     }
 }
 
-impl<'de, const T: usize> Deserialize<'de> for Matrix<'de, T> {
+impl<'de, const T: usize> Deserialize<'de> for Matrix<'_, T> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -95,7 +95,7 @@ impl<const T: usize> Serialize for Matrix<'_, T> {
 mod tests {
     use super::Matrix;
     use crate::{Dtb, DtbPtr, buildin::Node, from_raw_mut};
-    use serde_derive::Serialize;
+    use serde::Serialize;
 
     const MAX_SIZE: usize = 256;
     #[test]

src/de_mut/node_seq.rs

@@ -178,7 +178,7 @@ impl<'de> NodeSeqItem<'de> {
 mod tests {
     use crate::buildin::{NodeSeq, Reg};
     use crate::{Dtb, DtbPtr, from_raw_mut};
-    use serde_derive::Deserialize;
+    use serde::Deserialize;
 
     const RAW_DEVICE_TREE: &[u8] = include_bytes!("../../examples/bl808.dtb");
     const BUFFER_SIZE: usize = RAW_DEVICE_TREE.len();

src/ser/mod.rs

@@ -39,17 +39,16 @@ where
     let writer_len = writer.len();
     let (data_block, string_block) = writer.split_at_mut(writer.len() - offset);
     let (header, data_block) = data_block.split_at_mut(HEADER_LEN as usize + RSVMAP_LEN);
-    let struct_len;
-    {
+    let struct_len = {
         let mut patch_list = crate::ser::patch::PatchList::new(list);
         let mut block = crate::ser::string_block::StringBlock::new(string_block, &mut offset);
         let mut dst = crate::ser::pointer::Pointer::new(Some(data_block));
         let mut ser =
             crate::ser::serializer::Serializer::new(&mut dst, &mut block, &mut patch_list);
         data.serialize(&mut ser)?;
         ser.dst.step_by_u32(FDT_END);
-        struct_len = ser.dst.get_offset();
-    }
+        ser.dst.get_offset()
+    };
     // Make header
     {
         let header = unsafe { &mut *(header.as_mut_ptr() as *mut Header) };

src/ser/serializer.rs

@@ -450,7 +450,7 @@ impl<'se> serde::ser::Serializer for &mut Serializer<'se> {
 
 #[cfg(test)]
 mod tests {
-    use serde_derive::Serialize;
+    use serde::Serialize;
     const MAX_SIZE: usize = 256 + 32;
     #[test]
     fn base_ser_test() {

src/value/riscv_pmu.rs

@@ -1,29 +1,33 @@
-use crate::buildin::Matrix;
+use crate::buildin::*;
 
-use serde_derive::Serialize;
+use serde::{Deserialize, Serialize};
 
 use core::ops::RangeInclusive;
 
 #[repr(transparent)]
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize)]
 #[serde(transparent)]
-pub struct EventToMhpmevent<'de>(Matrix<'de, 3>);
+pub struct EventToMhpmevent<'a>(Matrix<'a, 3>);
 
 #[repr(transparent)]
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize)]
 #[serde(transparent)]
-pub struct EventToMhpmcounters<'de>(Matrix<'de, 3>);
+pub struct EventToMhpmcounters<'a>(Matrix<'a, 3>);
 
 #[repr(transparent)]
-#[derive(Serialize)]
+#[derive(Deserialize, Serialize)]
 #[serde(transparent)]
-pub struct RawEventToMhpcounters<'de>(Matrix<'de, 5>);
+pub struct RawEventToMhpcounters<'a>(Matrix<'a, 5>);
 
 impl EventToMhpmevent<'_> {
-    pub fn get_len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.0.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     pub fn get_event_id(&self, i: usize) -> u32 {
         u32::from_be(self.0.get(i)[0])
     }
@@ -35,10 +39,14 @@ impl EventToMhpmevent<'_> {
 }
 
 impl EventToMhpmcounters<'_> {
-    pub fn get_len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.0.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     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])
@@ -51,10 +59,14 @@ impl EventToMhpmcounters<'_> {
 }
 
 impl RawEventToMhpcounters<'_> {
-    pub fn get_len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.0.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     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)
@@ -70,3 +82,41 @@ impl RawEventToMhpcounters<'_> {
         u32::from_be(current[4])
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::EventToMhpmcounters;
+    use crate::{Dtb, DtbPtr, buildin::Node, from_raw_mut};
+
+    const RAW_DEVICE_TREE: &[u8] = include_bytes!("../../examples/qemu-virt.dtb");
+    const BUFFER_SIZE: usize = RAW_DEVICE_TREE.len();
+    #[test]
+    fn test_chosen_stdout() {
+        #[repr(align(8))]
+        struct AlignedBuffer {
+            pub data: [u8; RAW_DEVICE_TREE.len()],
+        }
+        let mut aligned_data: Box<AlignedBuffer> = Box::new(AlignedBuffer {
+            data: [0; BUFFER_SIZE],
+        });
+        aligned_data.data[..BUFFER_SIZE].clone_from_slice(RAW_DEVICE_TREE);
+        let mut slice = aligned_data.data.to_vec();
+        let ptr = DtbPtr::from_raw(slice.as_mut_ptr()).unwrap();
+        let dtb = Dtb::from(ptr).share();
+
+        let node: Node = from_raw_mut(&dtb).unwrap();
+        let result = node
+            .find("/pmu")
+            .unwrap()
+            .get_prop("riscv,event-to-mhpmcounters")
+            .unwrap()
+            .deserialize::<EventToMhpmcounters>();
+        assert_eq!(result.len(), 5);
+        assert_eq!(result.get_event_idx_range(0), 1..=1);
+        assert_eq!(result.get_counter_bitmap(0), 0x7fff9);
+        assert_eq!(result.get_event_idx_range(1), 2..=2);
+        assert_eq!(result.get_counter_bitmap(1), 0x7fffc);
+        assert_eq!(result.get_event_idx_range(2), 0x10019..=0x10019);
+        assert_eq!(result.get_counter_bitmap(2), 0x7fff8);
+    }
+}