Merge pull request verilog-to-routing#5 from litghost/fasm_param

Add initial FASM parameter support

Author: litghost

utils/fasm/CMakeLists.txt

@@ -8,6 +8,8 @@ add_library(fasm
   src/fasm.h
   src/lut.cpp
   src/lut.h
+  src/parameters.cpp
+  src/parameters.h
   )
 target_include_directories(fasm PUBLIC src)
 target_link_libraries(fasm

utils/fasm/src/fasm.cpp

@@ -228,6 +228,7 @@ void FasmWriterVisitor::visit_all_impl(const t_pb_route *pb_route, const t_pb* p
 
 void FasmWriterVisitor::visit_open_impl(const t_pb* atom) {
   check_for_lut(atom);
+  check_for_param(atom);
 }
 
 static AtomNetId _find_atom_input_logical_net(const t_pb* atom, const t_pb_route *pb_route, int atom_input_idx) {
@@ -264,7 +265,6 @@ static LogicVec lut_outputs(const t_pb* atom_pb, size_t num_inputs, const t_pb_r
 
     VTR_ASSERT(gnode->num_input_ports == 1);
     //VTR_ASSERT(gnode->num_input_pins[0] >= num_inputs);
-    std::cerr << num_inputs << std::endl;
     std::vector<vtr::LogicValue> inputs(num_inputs, vtr::LogicValue::DONT_CARE);
     std::vector<int> permutation(num_inputs, -1);
 
@@ -424,6 +424,59 @@ static const t_pb_route *find_pb_route(const t_pb* pb) {
   return nullptr;
 }
 
+void FasmWriterVisitor::check_for_param(const t_pb *atom) {
+    auto& atom_ctx = g_vpr_ctx.atom();
+
+    auto atom_blk_id = atom_ctx.lookup.pb_atom(atom);
+    if (atom_blk_id == AtomBlockId::INVALID()) {
+        return;
+    }
+
+    if(atom->pb_graph_node == nullptr ||
+       atom->pb_graph_node->pb_type == nullptr ||
+       atom->pb_graph_node->pb_type->meta == nullptr) {
+        return;
+    }
+
+    const auto *meta = atom->pb_graph_node->pb_type->meta;
+    if(!meta->has("fasm_params")) {
+        return;
+    }
+
+    auto iter = parameters_.find(atom->pb_graph_node->pb_type);
+
+    if(iter == parameters_.end()) {
+        Parameters params;
+        std::string fasm_params = meta->one("fasm_params")->as_string();
+        for(const auto param : vtr::split(fasm_params, "\n")) {
+            auto param_parts = vtr::split(vtr::replace_all(param, " ", ""), "=");
+            if(param_parts.size() == 0) {
+                continue;
+            }
+            VTR_ASSERT(param_parts.size() == 2);
+
+            params.AddParameter(param_parts[1], param_parts[0]);
+        }
+
+        auto ret = parameters_.insert(std::make_pair(
+                    atom->pb_graph_node->pb_type,
+                    params));
+
+        VTR_ASSERT(ret.second);
+        iter = ret.first;
+    }
+
+    auto &params = iter->second;
+
+    for(auto param : atom_ctx.nlist.block_params(atom_blk_id)) {
+        auto feature = params.EmitFasmFeature(param.first, param.second);
+
+        if(feature.size() > 0) {
+            output_fasm_features(feature);
+        }
+    }
+}
+
 void FasmWriterVisitor::check_for_lut(const t_pb* atom) {
     auto& atom_ctx = g_vpr_ctx.atom();
 
@@ -446,6 +499,7 @@ void FasmWriterVisitor::check_for_lut(const t_pb* atom) {
 
 void FasmWriterVisitor::visit_atom_impl(const t_pb* atom) {
   check_for_lut(atom);
+  check_for_param(atom);
 }
 
 void FasmWriterVisitor::walk_routing() {

utils/fasm/src/fasm.h

@@ -14,6 +14,7 @@
 #include "netlist_walker.h"
 #include "netlist_writer.h"
 #include "lut.h"
+#include "parameters.h"
 
 namespace fasm {
 
@@ -42,6 +43,7 @@ class FasmWriterVisitor : public NetlistVisitor {
       void walk_routing();
       std::string build_clb_prefix(const t_pb_graph_node* pb_graph_node) const;
       const LutOutputDefinition* find_lut(const t_pb_graph_node* pb_graph_node);
+      void check_for_param(const t_pb *atom);
 
       std::ostream& os_;
 
@@ -53,6 +55,7 @@ class FasmWriterVisitor : public NetlistVisitor {
       ClusterBlockId current_blk_id_;
       std::vector<t_pb_graph_pin**> pb_graph_pin_lookup_from_index_by_type_;
       std::map<const t_pb_type*, std::vector<std::pair<std::string, LutOutputDefinition>>> lut_definitions_;
+      std::map<const t_pb_type*, Parameters> parameters_;
 };
 
 } // namespace fasm

utils/fasm/src/parameters.cpp

@@ -0,0 +1,62 @@
+#include "parameters.h"
+#include "vtr_assert.h"
+
+namespace fasm {
+
+void Parameters::AddParameter(const std::string &eblif_parameter, const std::string &fasm_feature) {
+    auto ret = features_.insert(std::make_pair(eblif_parameter, FeatureParameter()));
+
+    VTR_ASSERT(ret.second);
+
+    ret.first->second.feature = fasm_feature;
+    ret.first->second.width = FeatureWidth(fasm_feature);
+}
+
+std::string Parameters::EmitFasmFeature(const std::string &eblif_parameter, const std::string &value) {
+    auto iter = features_.find(eblif_parameter);
+    if(iter == features_.end()) {
+        return "";
+    }
+
+    // Parameter should have exactly the expected number of bits.
+    if(value.size() != iter->second.width) {
+        vpr_throw(VPR_ERROR_OTHER,
+                __FILE__, __LINE__, "When emitting FASM for parameter %s, expected width of %d got width of %d, value = \"%s\".",
+                eblif_parameter.c_str(), iter->second.width, value.size(), value.c_str());
+    }
+    VTR_ASSERT(value.size() == iter->second.width);
+
+    return vtr::string_fmt("%s=%d'b%s", iter->second.feature.c_str(),
+            iter->second.width, value.c_str());
+}
+
+size_t Parameters::FeatureWidth(const std::string &feature) const {
+    size_t start_of_address = feature.rfind('[');
+    size_t end_of_address = feature.rfind(']');
+
+    if(start_of_address == std::string::npos) {
+        VTR_ASSERT(end_of_address == std::string::npos);
+        return 1;
+    }
+
+    VTR_ASSERT(end_of_address > start_of_address+1);
+
+    auto address = feature.substr(start_of_address+1, end_of_address - start_of_address - 1);
+
+    size_t address_split = address.find(':');
+
+    if(address_split == std::string::npos) {
+        return 1;
+    }
+
+    VTR_ASSERT(address_split > 0);
+    VTR_ASSERT(address_split+1 < address.size());
+
+    int high_slice = vtr::atoi(address.substr(0, address_split));
+    int low_slice = vtr::atoi(address.substr(address_split+1));
+    VTR_ASSERT(high_slice >= low_slice);
+
+    return high_slice - low_slice + 1;
+}
+
+} // namespace fasm

utils/fasm/src/parameters.h

@@ -0,0 +1,30 @@
+#ifndef PARAMETERS_H
+#define PARAMETERS_H
+
+#include "netlist_writer.h"
+
+namespace fasm {
+
+// Utility class emit parameters from eblif
+class Parameters {
+ public:
+  // Adds a parameter mapping between an eblif parameter (e.g. .param <param> <value>)
+  // to FASM feature.
+  void AddParameter(const std::string &eblif_parameter, const std::string &fasm_feature);
+
+  // Return a FASM feature directive for the given parameter and value.
+  std::string EmitFasmFeature(const std::string &eblif_parameter, const std::string &value);
+ private:
+  struct FeatureParameter {
+      size_t width;
+      std::string feature;
+  };
+
+  std::unordered_map<std::string, FeatureParameter> features_;
+
+  size_t FeatureWidth(const std::string &feature) const;
+};
+
+} // namespace fasm
+
+#endif  // PARAMETERS_H