move operator==() and hash function of t_rr_switch_inf to physical_types.cpp

Author: soheilshahrouz

libs/libarchfpga/src/physical_types.cpp

@@ -71,10 +71,47 @@ bool t_rr_switch_inf::configurable() const {
     return switch_type_is_configurable(type());
 }
 
+bool t_rr_switch_inf::operator==(const t_rr_switch_inf& other) const {
+    return R == other.R &&
+           Cin == other.Cin &&
+           Cout == other.Cout &&
+           Cinternal == other.Cinternal &&
+           Tdel == other.Tdel &&
+           mux_trans_size == other.mux_trans_size &&
+           buf_size == other.buf_size &&
+           power_buffer_type == other.power_buffer_type &&
+           power_buffer_size == other.power_buffer_size &&
+           intra_tile == other.intra_tile &&
+           type() == other.type();
+}
+
+std::size_t t_rr_switch_inf::Hasher::operator()(const t_rr_switch_inf& s) const {
+    std::size_t seed = 0;
+
+    auto hash_combine = [&seed](auto&& val) {
+        seed ^= std::hash<std::decay_t<decltype(val)>>{}(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    };
+
+    hash_combine(s.R);
+    hash_combine(s.Cin);
+    hash_combine(s.Cout);
+    hash_combine(s.Cinternal);
+    hash_combine(s.Tdel);
+    hash_combine(s.mux_trans_size);
+    hash_combine(s.buf_size);
+    hash_combine(static_cast<int>(s.power_buffer_type));
+    hash_combine(s.power_buffer_size);
+    hash_combine(s.intra_tile);
+    hash_combine(static_cast<int>(s.type()));
+
+    return seed;
+}
+
 void t_rr_switch_inf::set_type(SwitchType type_val) {
     type_ = type_val;
 }
 
+
 static bool switch_type_is_buffered(SwitchType type) {
     //Muxes and Tristates isolate their input and output into
     //separate DC connected sub-circuits
@@ -360,4 +397,4 @@ const t_physical_tile_port* t_sub_tile::get_port_by_pin(int pin) const {
     }
 
     return nullptr;
-}
+}

libs/libarchfpga/src/physical_types.h

@@ -1917,16 +1917,22 @@ struct t_rr_switch_inf {
     bool intra_tile = false;
 
   public:
-    //Returns the type of switch
+    /// Returns the type of switch
     SwitchType type() const;
 
-    //Returns true if this switch type isolates its input and output into
-    //separate DC-connected subcircuits
+    /// Returns true if this switch type isolates its input and output into
+    /// separate DC-connected subcircuits
     bool buffered() const;
 
-    //Returns true if this switch type is configurable
+    /// Returns true if this switch type is configurable
     bool configurable() const;
 
+    bool operator==(const t_rr_switch_inf& other) const;
+
+    struct Hasher {
+        std::size_t operator()(const t_rr_switch_inf& s) const;
+    };
+
   public:
     void set_type(SwitchType type_val);
 

libs/librrgraph/src/io/rr_graph_reader.cpp

@@ -172,55 +172,13 @@ static RREdgeId process_rr_edge_override(const std::string& line,
     return edge_id;
 }
 
-struct t_rr_switch_inf_hash {
-    std::size_t operator()(const t_rr_switch_inf& s) const {
-        std::size_t seed = 0;
-
-        // Helper function for hashing
-        auto hash_combine = [&seed](auto&& val) {
-            seed ^= std::hash<std::decay_t<decltype(val)>>{}(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-        };
-
-        // Combine all relevant fields
-        hash_combine(s.R);
-        hash_combine(s.Cin);
-        hash_combine(s.Cout);
-        hash_combine(s.Cinternal);
-        hash_combine(s.Tdel);
-        hash_combine(s.mux_trans_size);
-        hash_combine(s.buf_size);
-        hash_combine(static_cast<int>(s.power_buffer_type));
-        hash_combine(s.power_buffer_size);
-        hash_combine(s.intra_tile);
-        hash_combine(static_cast<int>(s.type()));
-
-        return seed;
-    }
-};
-
-struct t_rr_switch_inf_equal {
-    bool operator()(const t_rr_switch_inf& lhs, const t_rr_switch_inf& rhs) const {
-        return lhs.R == rhs.R &&
-               lhs.Cin == rhs.Cin &&
-               lhs.Cout == rhs.Cout &&
-               lhs.Cinternal == rhs.Cinternal &&
-               lhs.Tdel == rhs.Tdel &&
-               lhs.mux_trans_size == rhs.mux_trans_size &&
-               lhs.buf_size == rhs.buf_size &&
-               lhs.power_buffer_type == rhs.power_buffer_type &&
-               lhs.power_buffer_size == rhs.power_buffer_size &&
-               lhs.intra_tile == rhs.intra_tile &&
-               lhs.type() == rhs.type();
-    }
-};
-
 void load_rr_edge_delay_overrides(std::string_view filename,
                                   RRGraphBuilder& rr_graph_builder,
                                   const RRGraphView& rr_graph) {
     std::ifstream file(filename.data());
     VTR_LOGV_ERROR(!file, "Failed to open the RR edge override file: %s\n", filename.data());
 
-    std::unordered_map<t_rr_switch_inf, RRSwitchId, t_rr_switch_inf_hash, t_rr_switch_inf_equal> unique_switch_info;
+    std::unordered_map<t_rr_switch_inf, RRSwitchId, t_rr_switch_inf::Hasher> unique_switch_info;
     for (const auto& [rr_sw_idx, sw] : rr_graph.rr_switch().pairs()) {
         unique_switch_info.insert({sw, rr_sw_idx});
     }