Enable c++ model parameterisation, apply to gpio

Author: robtaylor

chipflow_lib/common/sim/models.cc

@@ -274,39 +274,6 @@ void uart_model::step(unsigned timestamp) {
     }
 }
 
-// GPIO
-
-void gpio_model::step(unsigned timestamp) {
-    uint32_t o_value = o.get<uint32_t>();
-    uint32_t oe_value = oe.get<uint32_t>();
-
-    for (auto action : get_pending_actions(name)) {
-        if (action.event == "set") {
-            auto bin = std::string(action.payload);
-            input_data = 0;
-            for (unsigned i = 0; i < pin_count; i++) {
-                if (bin.at((pin_count - 1) - i) == '1')
-                    input_data |= (1U << i);
-            }
-        }
-    }
-
-    if (o_value != s.o_last || oe_value != s.oe_last) {
-        std::string formatted_value;
-        for (int i = pin_count - 1; i >= 0; i--) {
-            if (oe_value & (1U << unsigned(i)))
-                formatted_value += (o_value & (1U << unsigned(i))) ? '1' : '0';
-            else
-                formatted_value += 'Z';
-        }
-        log_event(timestamp, name, "change", json(formatted_value));
-    }
-
-    i.set((input_data & ~oe_value) | (o_value & oe_value));
-    s.o_last = o_value;
-    s.oe_last = oe_value;
-}
-
 // Generic SPI model
 void spi_model::step(unsigned timestamp) {
     for (auto action : get_pending_actions(name)) {

chipflow_lib/common/sim/models.h

@@ -82,14 +82,11 @@ struct uart_model {
     } s;
 };
 
+template<int pin_count>
 struct gpio_model {
     std::string name;
-    struct parameters {
-        unsigned pin_count;
-    };
-    parameters parameters;
 
-    gpio_model(const std::string &name, parameters, const value<paramters.pin_count> &o, const value<parameters.pin_count> &oe, value<parameters.pin_count> &i) : name(name), parameters(parameters), o(o), oe(oe), i(i) {};
+    gpio_model(const std::string &name, const value<pin_count> &o, const value<pin_count> &oe, value<pin_count> &i) : name(name), o(o), oe(oe), i(i) {};
 
     void step(unsigned timestamp);
 
@@ -105,6 +102,39 @@ struct gpio_model {
 };
 
 
+// GPIO
+template<int pin_count>
+void gpio_model<pin_count>::step(unsigned timestamp) {
+    uint32_t o_value = o.template get<uint32_t>();
+    uint32_t oe_value = oe.template get<uint32_t>();
+
+    for (auto action : get_pending_actions(name)) {
+        if (action.event == "set") {
+            auto bin = std::string(action.payload);
+            input_data = 0;
+            for (unsigned i = 0; i < pin_count; i++) {
+                if (bin.at((pin_count - 1) - i) == '1')
+                    input_data |= (1U << i);
+            }
+        }
+    }
+
+    if (o_value != s.o_last || oe_value != s.oe_last) {
+        std::string formatted_value;
+        for (int i = pin_count - 1; i >= 0; i--) {
+            if (oe_value & (1U << unsigned(i)))
+                formatted_value += (o_value & (1U << unsigned(i))) ? '1' : '0';
+            else
+                formatted_value += 'Z';
+        }
+        log_event(timestamp, name, "change", json(formatted_value));
+    }
+
+    i.set((input_data & ~oe_value) | (o_value & oe_value));
+    s.o_last = o_value;
+    s.oe_last = oe_value;
+}
+
 struct spi_model {
     std::string name;
     spi_model(const std::string &name, const value<1> &clk, const value<1> &copi, value<1> &cipo, const value<1> &csn) : 

chipflow_lib/platforms/_signatures.py

@@ -18,6 +18,12 @@ class SimInterface(TypedDict):
 
 _VALID_UID = re.compile('[a-zA-Z_.]').search
 
+"""
+Attributes:
+    __chipflow_parameters__: list of tuples (name, value).
+        It is expected that a model that takes parameters is implmemted as a template, with the parameters in the order
+        given.
+"""
 def sim_annotate(base="com.chipflow.chipflow_lib"):
     def decorate(klass):
         assert _VALID_UID(base)
@@ -35,7 +41,7 @@ def new_init(self,*args, **kwargs):
         klass.__init__ = new_init
         klass.__chipflow_uid__ = f"{base}.{klass.__name__}"
         if not hasattr(klass, '__chipflow_parameters__'):
-            klass.__chipflow_parameters__ = lambda self: {}
+            klass.__chipflow_parameters__ = lambda self: []
         return klass
     return decorate
 
@@ -100,7 +106,7 @@ def __init__(self, pin_count=1, **kwargs: Unpack[IOModelOptions]):
             })
 
     def __chipflow_parameters__(self):
-        return {'pin_count': self._pin_count}
+        return [('pin_count',self._pin_count)]
 
     def __repr__(self) -> str:
         return f"GPIOSignature(pin_count={self._pin_count}, {dict(self.members.items())})"

chipflow_lib/platforms/sim.py

@@ -110,7 +110,7 @@ def instantiate_model(self, interface: str, sim_interface: SimInterface, interfa
             logger.warn(f"Unable to find simulation model for '{sim_interface}'")
 
         model = self._table[uid]
-        sig = model.signature(**parameters)
+        sig = model.signature(**dict(parameters))
         members = list(sig.flatten(sig.create()))
 
         sig_names = [ path for path, _, _ in members ]
@@ -120,12 +120,13 @@ def instantiate_model(self, interface: str, sim_interface: SimInterface, interfa
         names = [f"\\io${port_names[str(n)]}${d}" for n,d in sig_names]
         params = [f"top.{cxxrtlmangle(n)}" for n in names]
 
-        out = f"{model.name} {interface}(\"{interface}\", "
+        cpp_class = model.name
         if len(parameters):
-            cpp_params = []
-            for p,v in parameters.items():
-                cpp_params.append(f"{p} = {v}")
-            out += '{' + ', '.join(cpp_params) + '}, '
+            template_params = []
+            for p,v in parameters:
+                template_params.append(f"{v}")
+            cpp_class = cpp_class + '<' + ', '.join(template_params) + '>'
+        out = f"{cpp_class} {interface}(\"{interface}\", "
         out += ', '.join(list(params))
         out += ')\n'
         return out