Renamed op type members. (#2469)

Renamed op type members from attr to legacy_attrs_ and from named_attrs
to named_attrs_.

Author: acolicTT

forge/csrc/autograd/autograd.cpp

@@ -360,13 +360,13 @@ void autograd_engine::create_backward_graph(const grad_map &requires_grad_map)
             {
                 if (tm.type() == ops::OpType::Broadcast)
                 {
-                    TT_ASSERT(tm.attr.size() <= 3);
+                    TT_ASSERT(tm.legacy_attrs_.size() <= 3);
                     log_debug(
                         tt::LogAutograd,
                         "Edge has broadcast: dim={} size={}",
-                        std::get<int>(tm.attr[0]),
-                        std::get<int>(tm.attr[1]));
-                    int dim = std::get<int>(tm.attr[0]);
+                        std::get<int>(tm.legacy_attrs_[0]),
+                        std::get<int>(tm.legacy_attrs_[1]));
+                    int dim = std::get<int>(tm.legacy_attrs_[0]);
 
                     NodeContext src = last_out;
                     last_out = create_backward_op(

forge/csrc/graph_lib/node_types.cpp

@@ -335,7 +335,7 @@ void EdgeAttributes::clear_broadcast_dims()
 void EdgeAttributes::remove_broadcast_dim(int dim)
 {
     auto filter = [=](const OpType &o)
-    { return o.type() == ops::OpType::Broadcast && std::get<int>(o.attr[0]) == dim; };
+    { return o.type() == ops::OpType::Broadcast && std::get<int>(o.legacy_attrs_[0]) == dim; };
     tms.erase(std::remove_if(tms.begin(), tms.end(), filter), tms.end());
 }
 

forge/csrc/graph_lib/node_types.hpp

@@ -374,15 +374,15 @@ struct OpType
     using Attrs = ForgeOpAttrs;
 
     std::string op_;
-    std::vector<Attr> attr;  // legacy path
-    Attrs named_attrs;       // new path
+    std::vector<Attr> legacy_attrs_;  // legacy path
+    Attrs named_attrs_;               // new path
 
    private:
     ops::Op new_op_;
 
    public:
     OpType(std::string const &op, std::vector<Attr> const &attr = {}, Attrs named_attrs = {}) :
-        op_(op), attr(attr), named_attrs(std::move(named_attrs)), new_op_(*this)
+        op_(op), legacy_attrs_(attr), named_attrs_(std::move(named_attrs)), new_op_(*this)
     {
     }
 
@@ -391,14 +391,14 @@ struct OpType
 
     bool operator==(const OpType &other) const
     {
-        return *this == other.type() and attr == other.attr and named_attrs == other.named_attrs;
+        return *this == other.type() and legacy_attrs_ == other.legacy_attrs_ and named_attrs_ == other.named_attrs_;
     }
     bool operator!=(const OpType &other) const { return !(*this == other); }
 
     ops::OpType type() const { return new_op_.type(); }
     ops::Op const &new_op() const { return new_op_; }
-    Attr const &get_attr(std::string const &name) const { return named_attrs.at(name); }
-    Attr &get_attr(std::string const &name) { return named_attrs.at(name); }
+    Attr const &get_attr(std::string const &name) const { return named_attrs_.at(name); }
+    Attr &get_attr(std::string const &name) { return named_attrs_.at(name); }
     template <typename T>
     T const &get_attr_as(std::string const &name) const
     {
@@ -412,7 +412,7 @@ struct OpType
 
     void set_attr(std::string const &name, Attr attr)
     {
-        named_attrs[name] = attr;
+        named_attrs_[name] = attr;
         new_op_.set_attr(name, std::move(attr));
     }
 
@@ -421,30 +421,30 @@ struct OpType
     std::string as_string() const
     {
         std::string ret = op_;
-        if (attr.size() > 0)
+        if (legacy_attrs_.size() > 0)
         {
             ret += "(";
-            for (unsigned int i = 0; i < attr.size(); i++)
+            for (unsigned int i = 0; i < legacy_attrs_.size(); i++)
             {
-                if (std::holds_alternative<bool>(attr[i]))
+                if (std::holds_alternative<bool>(legacy_attrs_[i]))
                 {
-                    ret += std::to_string(std::get<bool>(attr[i])) + ",";
+                    ret += std::to_string(std::get<bool>(legacy_attrs_[i])) + ",";
                 }
-                else if (std::holds_alternative<int>(attr[i]))
+                else if (std::holds_alternative<int>(legacy_attrs_[i]))
                 {
-                    ret += std::to_string(std::get<int>(attr[i])) + ",";
+                    ret += std::to_string(std::get<int>(legacy_attrs_[i])) + ",";
                 }
-                else if (std::holds_alternative<float>(attr[i]))
+                else if (std::holds_alternative<float>(legacy_attrs_[i]))
                 {
-                    ret += std::to_string(std::get<float>(attr[i])) + ",";
+                    ret += std::to_string(std::get<float>(legacy_attrs_[i])) + ",";
                 }
-                else if (std::holds_alternative<std::string>(attr[i]))
+                else if (std::holds_alternative<std::string>(legacy_attrs_[i]))
                 {
-                    ret += std::get<std::string>(attr[i]) + ",";
+                    ret += std::get<std::string>(legacy_attrs_[i]) + ",";
                 }
-                else if (std::holds_alternative<std::vector<int>>(attr[i]))
+                else if (std::holds_alternative<std::vector<int>>(legacy_attrs_[i]))
                 {
-                    auto attr_val = std::get<std::vector<int>>(attr[i]);
+                    auto attr_val = std::get<std::vector<int>>(legacy_attrs_[i]);
                     size_t num_items = attr_val.size();
 
                     ret += "[";
@@ -466,13 +466,13 @@ struct OpType
             ret += ")";
         }
 
-        if (named_attrs.size() > 0)
+        if (named_attrs_.size() > 0)
         {
             using tt::operator<<;
             std::stringstream ss;
             bool first = true;
             ss << "{";
-            for (auto const &[name, value] : named_attrs)
+            for (auto const &[name, value] : named_attrs_)
             {
                 if (not first)
                     ss << ", ";
@@ -549,8 +549,8 @@ class OpNode : public TaggedNode
     OpType const *op_type_ptr() const { return &op_type_; }
     IRLevel get_ir_level() const { return IRLevel::IR_TT_FORGE; }
     const std::string &op_name() const { return op_type_.name(); }
-    const std::vector<OpType::Attr> &op_attrs() const { return op_type_.attr; }
-    const OpType::Attrs &named_attrs() { return op_type_.named_attrs; }
+    const std::vector<OpType::Attr> &op_legacy_attrs() const { return op_type_.legacy_attrs_; }
+    const OpType::Attrs &named_attrs() { return op_type_.named_attrs_; }
     const OpType::Attr &op_attr(std::string const &name) const { return op_type_.get_attr(name); }
     template <typename T>
     const T &op_attr_as(std::string const &name) const

forge/csrc/graph_lib/python_bindings.cpp

@@ -293,8 +293,8 @@ void GraphModule(py::module &m_graph)
             py::arg("attr") = std::vector<tt::graphlib::OpType::Attr>{},
             py::arg("named_attrs") = tt::graphlib::OpType::Attrs{})
         .def_readonly("op", &tt::graphlib::OpType::op_)
-        .def_readonly("attr", &tt::graphlib::OpType::attr)
-        .def_readonly("named_attrs", &tt::graphlib::OpType::named_attrs)
+        .def_readonly("attr", &tt::graphlib::OpType::legacy_attrs_)
+        .def_readonly("named_attrs", &tt::graphlib::OpType::named_attrs_)
         .def("eval", &tt::graphlib::OpType::eval)
         .def("shape", &tt::graphlib::OpType::shape)
         .def(

forge/csrc/graph_lib/utils.cpp

@@ -1148,7 +1148,7 @@ void convert_implicit_to_explicit_bcasts(Graph *graph, Edge edge)
         if (op_type.type() == ops::OpType::Broadcast)
         {
             constexpr bool explicit_bcast = true;
-            std::get<bool>(op_type.attr[2]) = explicit_bcast;
+            std::get<bool>(op_type.legacy_attrs_[2]) = explicit_bcast;
         }
     }
 }
@@ -1208,9 +1208,9 @@ bool swap_broadcast_dims(graphlib::Graph *graph, graphlib::Edge edge, int old_di
     {
         if (op_type.type() == ops::OpType::Broadcast)
         {
-            int dim = std::get<int>(op_type.attr[0]);
-            int size = std::get<int>(op_type.attr[1]);
-            bool explicit_bcast = std::get<bool>(op_type.attr[2]);
+            int dim = std::get<int>(op_type.legacy_attrs_[0]);
+            int size = std::get<int>(op_type.legacy_attrs_[1]);
+            bool explicit_bcast = std::get<bool>(op_type.legacy_attrs_[2]);
             if (dim == old_dim)
             {
                 graphlib::OpType updated_bcast("broadcast", {new_dim, size, explicit_bcast});
@@ -1310,8 +1310,8 @@ void handle_change_rank(graphlib::Graph *graph, graphlib::Edge edge)
     {
         if (op_type.type() == ops::OpType::Broadcast)
         {
-            if (std::get<int>(op_type.attr[0]) >= 0)
-                std::get<int>(op_type.attr[0]) += diff;
+            if (std::get<int>(op_type.legacy_attrs_[0]) >= 0)
+                std::get<int>(op_type.legacy_attrs_[0]) += diff;
         }
     }
     graph->get_edge_attributes(edge)->set_tms(tms);
@@ -1846,9 +1846,9 @@ bool is_consteval_capable_input_no_operand_forks(Graph *graph, InputNode *input)
     if (not std::all_of(user_ops.begin(), user_ops.end(), [op_name](OpNode *n) { return n->op_name() == op_name; }))
         return false;
 
-    auto attrs = user_ops[0]->op_attrs();
+    auto attrs = user_ops[0]->op_legacy_attrs();
     for (OpNode *op : user_ops)
-        if (attrs != op->op_attrs())
+        if (attrs != op->op_legacy_attrs())
             return false;
 
     return true;

forge/csrc/ops/op.cpp

@@ -300,7 +300,7 @@ static NewToOldOpType new_to_old_op_type_mapper;
 static OldToNewOpType old_to_new_op_type_mapper;
 
 Op::Op(const graphlib::OpType &old_op_type) :
-    type_(old_to_new_op_type_mapper[old_op_type.op_]), attrs_(old_op_type.named_attrs)
+    type_(old_to_new_op_type_mapper[old_op_type.op_]), attrs_(old_op_type.named_attrs_)
 {
 }