Merge pull request #24 from Origen-SDK/block_loader

Problem getting a ref to DUT

Author: ginty

example/tests/registers_test.py

@@ -0,0 +1,18 @@
+import origen
+
+def test_memory_maps_can_be_fetched():
+    origen.app.instantiate_dut("dut.falcon")
+    assert origen.dut.memory_maps
+    assert len(origen.dut.memory_maps) == 1
+    #assert origen.dut.memory_map("default") == origen.dut.memory_maps["default"]
+
+def test_address_blocks_can_be_fetched():
+    pass
+
+def test_regs_can_be_fetched():
+    pass
+
+def test_register_value_can_be_read():
+    origen.app.instantiate_dut("dut.falcon")
+    #assert origen.dut.regs["reg1"].data == 0
+

python/origen/controller.py

@@ -38,6 +38,10 @@ def __getattr__(self, name):
             self.app.load_block_files(self, "sub_blocks.py")
             return self.sub_blocks
 
+        elif name == "memory_maps":
+            self.regs  # Ensure the memory maps for this block have been loaded
+            return origen.dut.db.memory_maps(self.path)
+
         else:
             raise AttributeError(f"The block '{self.block_path}' has no attribute '{name}'")
 
@@ -53,6 +57,11 @@ def tree_as_str(self):
             t = f"dut.{self.parent}.{self.id}"
         return t
 
+    def memory_map(self, id):
+        self.regs  # Ensure the memory maps for this block have been loaded
+        return origen.dut.db.memory_map(self.path, id)
+
+
 # The base class of all Origen controller objects which are also
 # the top-level (DUT)
 class TopLevel(Base):

rust/origen/pyapi/src/address_block.rs

@@ -0,0 +1 @@
+

rust/origen/pyapi/src/dut.rs

@@ -1,7 +1,7 @@
 use pyo3::prelude::*;
 //use pyo3::wrap_pyfunction;
-use origen::core::dut::DUT;
-use pyo3::exceptions;
+use crate::register::BitCollection;
+use origen::DUT;
 
 /// Implements the module _origen.dut in Python which exposes all
 /// DUT-related APIs
@@ -14,55 +14,59 @@ pub fn dut(_py: Python, m: &PyModule) -> PyResult<()> {
 
 #[pyclass]
 #[derive(Debug)]
-pub struct PyDUT {
-    dut: DUT,
-}
+pub struct PyDUT {}
 
 #[pymethods]
 impl PyDUT {
     #[new]
-    fn new(obj: &PyRawObject, id: String) {
-        obj.init({ PyDUT { dut: DUT::new(id) } });
+    /// Instantiating a new instance of PyDUT means re-loading the target
+    fn new(obj: &PyRawObject, id: &str) {
+        DUT.lock().unwrap().change(id);
+        obj.init({ PyDUT {} });
     }
 
     /// Creates a new model at the given path
-    fn create_sub_block(&mut self, path: &str, id: &str) -> PyResult<()> {
-        self.dut
-            .create_sub_block(path, id)
-            // Can't get the Origen errors to cast properly to a PyErr For some reason,
-            // so have to do this
-            .map_err(|e| exceptions::OSError::py_err(e.msg))
+    fn create_sub_block(&self, path: &str, id: &str) -> PyResult<()> {
+        Ok(DUT.lock().unwrap().create_sub_block(path, id)?)
     }
 
     fn create_reg(
-        &mut self,
+        &self,
         path: &str,
         memory_map: Option<&str>,
         address_block: Option<&str>,
         id: &str,
         offset: u32,
         size: Option<u32>,
     ) -> PyResult<()> {
-        // Can't get the Origen errors to cast properly to a PyErr For some reason,
-        // so have to do this
-        let model = match self.dut.get_mut_model(path) {
-            Ok(m) => m,
-            Err(e) => return Err(exceptions::OSError::py_err(e.msg)),
-        };
-        model
-            .create_reg(memory_map, address_block, id, offset, size)
-            // Can't get the Origen errors to cast properly to a PyErr For some reason,
-            // so have to do this
-            .map_err(|e| exceptions::OSError::py_err(e.msg))
+        let mut dut = DUT.lock().unwrap();
+        Ok(dut
+            .get_mut_model(path)?
+            .create_reg(memory_map, address_block, id, offset, size)?)
     }
 
     fn number_of_regs(&self, path: &str) -> PyResult<usize> {
-        // Can't get the Origen errors to cast properly to a PyErr For some reason,
-        // so have to do this
-        let model = match self.dut.get_model(path) {
-            Ok(m) => m,
-            Err(e) => return Err(exceptions::OSError::py_err(e.msg)),
-        };
+        let dut = DUT.lock().unwrap();
+        let model = dut.get_model(path)?;
         Ok(model.number_of_regs())
     }
+
+    fn get_reg(
+        &self,
+        path: &str,
+        memory_map: Option<&str>,
+        address_block: Option<&str>,
+        id: &str,
+    ) -> PyResult<BitCollection> {
+        let dut = DUT.lock().unwrap();
+        let model = dut.get_model(path)?;
+        let reg = model.get_reg(memory_map, address_block, id)?;
+
+        Ok(BitCollection::from_reg(
+            path,
+            memory_map,
+            address_block,
+            reg,
+        ))
+    }
 }

rust/origen/pyapi/src/lib.rs

@@ -1,6 +1,8 @@
+mod address_block;
 mod dut;
 mod logger;
-mod model;
+mod memory_map;
+mod register;
 
 use origen::{APPLICATION_CONFIG, ORIGEN_CONFIG, STATUS};
 use pyo3::prelude::*;
@@ -10,7 +12,6 @@ use pyo3::{wrap_pyfunction, wrap_pymodule};
 // Imported pyapi modules
 use dut::PyInit_dut;
 use logger::PyInit_logger;
-use model::PyInit_model;
 
 #[pymodule]
 /// This is the top-level _origen module which can be imported by Python
@@ -22,7 +23,6 @@ fn _origen(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(target_file))?;
 
     m.add_wrapped(wrap_pymodule!(logger))?;
-    m.add_wrapped(wrap_pymodule!(model))?;
     m.add_wrapped(wrap_pymodule!(dut))?;
     Ok(())
 }

rust/origen/pyapi/src/memory_map.rs

@@ -0,0 +1,56 @@
+// This module may be removed soon, replaced by the top-level DUT APIs
+use crate::dut::PyDUT;
+use origen::DUT;
+use pyo3::class::basic::PyObjectProtocol;
+use pyo3::class::PyMappingProtocol;
+use pyo3::prelude::*;
+
+/// Implements the user APIs dut[.sub_block].memory_map() and
+/// dut[.sub_block].memory_maps
+#[pymethods]
+impl PyDUT {
+    fn memory_maps(&self, path: &str) -> PyResult<MemoryMaps> {
+        let dut = DUT.lock().unwrap();
+        // Verify the model exists, though we don't need it for now
+        dut.get_model(path)?;
+        Ok(MemoryMaps {
+            model_path: path.to_string(),
+        })
+    }
+}
+
+/// Implements the user API to work with a model's collection of memory maps, an instance
+/// of this is returned by dut[.sub_block].memory_maps
+#[pyclass]
+#[derive(Debug)]
+pub struct MemoryMaps {
+    /// The path to the model which owns the contained memory maps
+    model_path: String,
+}
+
+/// User API methods, available to both Rust and Python
+#[pymethods]
+impl MemoryMaps {
+    fn len(&self) -> PyResult<usize> {
+        let dut = DUT.lock().unwrap();
+        let model = dut.get_model(&self.model_path)?;
+        Ok(model.memory_maps.len())
+    }
+}
+
+/// Internal, Rust-only methods
+impl MemoryMaps {}
+
+#[pyproto]
+impl PyMappingProtocol for MemoryMaps {
+    fn __len__(&self) -> PyResult<usize> {
+        self.len()
+    }
+}
+
+#[pyproto]
+impl PyObjectProtocol for MemoryMaps {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok("Here should be a nice graphic of the memory maps".to_string())
+    }
+}

rust/origen/pyapi/src/model.rs

@@ -0,0 +1,47 @@
+use origen::core::model::registers::Register;
+use pyo3::prelude::*;
+
+/// A BitCollection represents either a whole register of a subset of a
+/// registers bits (not necessarily contiguous bits) and provides the user
+/// with the same API to set and consume register data in both cases.
+#[pyclass]
+#[derive(Debug)]
+pub struct BitCollection {
+    /// The path to the model which owns the parent register
+    model_path: String,
+    /// The name of the model's memory map which contains the register
+    memory_map: String,
+    /// The name of the memory map's address block which contains the register
+    address_block: String,
+    /// The ID of the parent register
+    reg_id: String,
+    /// When true the BitCollection contains an entire register's worth of bits
+    whole: bool,
+    /// The index numbers of the bits from the register that are included in this
+    /// collection. Typically this will be mapped to the actual register bits by
+    /// BitCollection's methods.
+    bit_numbers: Vec<u16>,
+}
+
+/// Rust-private methods, i.e. not accessible from Python
+impl BitCollection {
+    pub fn from_reg(
+        path: &str,
+        memory_map: Option<&str>,
+        address_block: Option<&str>,
+        reg: &Register,
+    ) -> BitCollection {
+        BitCollection {
+            model_path: path.to_string(),
+            memory_map: memory_map.unwrap_or("default").to_string(),
+            address_block: address_block.unwrap_or("default").to_string(),
+            reg_id: reg.id.clone(),
+            whole: true,
+            bit_numbers: Vec::new(),
+        }
+    }
+}
+
+/// Methods available from Rust and Python
+#[pymethods]
+impl BitCollection {}

rust/origen/pyapi/src/register.rs

@@ -3,19 +3,27 @@ use crate::error::Error;
 use crate::Result;
 
 #[derive(Debug)]
-pub struct DUT {
+pub struct Dut {
     pub id: String,
     pub model: Model,
 }
 
-impl DUT {
-    pub fn new(id: String) -> DUT {
-        DUT {
-            id: id.clone(),
+impl Dut {
+    pub fn new(id: &str) -> Dut {
+        Dut {
+            id: id.to_string(),
             model: Model::new("".to_string(), "".to_string()),
         }
     }
 
+    /// Change the DUT, this replaces the existing mode with a fresh one (i.e.
+    /// deletes all current DUT metadata and state, and updates the name/ID field
+    /// with the given value
+    pub fn change(&mut self, id: &str) {
+        self.id = id.to_string();
+        self.model = Model::new("".to_string(), "".to_string());
+    }
+
     /// Get a mutable reference to the model at the given path
     /// Note that the path is relative to the DUT, i.e. it should not include 'dut.'
     pub fn get_mut_model(&mut self, path: &str) -> Result<&mut Model> {