Create op. builders (4.)

src/onnx/include/migraphx/onnx/onnx_parser.hpp

@@ -110,6 +110,7 @@ struct onnx_parser
     std::unordered_map<std::string, op_func> ops;
 
     onnx_parser();
+    value load_to_value(const std::string& name, const node_info& info) const;
     operation load(const std::string& name, const node_info& info) const;
 
     void parse_undefined(module* mod, const std::string& name);

src/onnx/onnx_parser.cpp

@@ -204,7 +204,7 @@ onnx_parser::onnx_parser()
         ops.emplace(name, get_op_parser(name));
 }
 
-operation onnx_parser::load(const std::string& name, const node_info& info) const
+value onnx_parser::load_to_value(const std::string& name, const node_info& info) const
 {
     auto op = make_op(name);
     auto v  = op.to_value();
@@ -228,7 +228,13 @@ operation onnx_parser::load(const std::string& name, const node_info& info) cons
             s.visit([&](auto y) { x = y.front(); });
         }
     }
-    op.from_value(v);
+    return v;
+}
+
+operation onnx_parser::load(const std::string& name, const node_info& info) const
+{
+    auto op = make_op(name);
+    op.from_value(load_to_value(name, info));
     return op;
 }
 

src/onnx/parse_binary_op.cpp

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2024 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2025 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,8 +23,8 @@
  */
 #include <migraphx/onnx/op_parser.hpp>
 #include <migraphx/ranges.hpp>
+#include <migraphx/op/builder/insert.hpp>
 #include <migraphx/instruction.hpp>
-#include <migraphx/make_op.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -48,10 +48,12 @@ struct parse_binary_op : op_parser<parse_binary_op>
     instruction_ref parse(const op_desc& opd,
                           const onnx_parser& parser,
                           onnx_parser::node_info info,
-                          std::vector<instruction_ref> args) const
+                          const std::vector<instruction_ref>& args) const
     {
         if(args.size() != 2)
             MIGRAPHX_THROW("binary operators should have 2 operands");
+
+        value options("", {}, false);
         if(contains(info.attributes, "broadcast") and contains(info.attributes, "axis"))
         {
             uint64_t broadcasted =
@@ -64,19 +66,13 @@ struct parse_binary_op : op_parser<parse_binary_op>
                     MIGRAPHX_THROW(
                         "Binary op broadcast attribute not supported for dynamic input shapes");
                 }
+
                 uint64_t axis = parser.parse_value(info.attributes.at("axis")).at<uint64_t>();
-                auto l        = info.add_instruction(
-                    make_op("broadcast",
-                            {{"axis", axis}, {"out_lens", args[0]->get_shape().lens()}}),
-                    args[1]);
-                return info.add_instruction(make_op(opd.op_name), args[0], l);
+                options.insert({"broadcasted_axis", axis});
             }
-            return info.add_instruction(make_op(opd.op_name), args);
-        }
-        else
-        {
-            return info.add_broadcastable_binary_op(opd.op_name, args[0], args[1]);
         }
+
+        return op::builder::add(opd.op_name, *info.mod, args, options).at(0);
     }
 };
 

src/onnx/parse_clip.cpp

@@ -49,7 +49,7 @@ struct parse_clip : op_parser<parse_clip>
             args.push_back(info.add_literal(max_val));
         }
 
-        return op::builder::add("clip", *info.mod, args, {}).at(0);
+        return op::builder::add("clip", *info.mod, args).at(0);
     }
 };
 

src/onnx/parse_gelu.cpp

@@ -88,7 +88,7 @@ struct parse_gelu : op_parser<parse_gelu>
         {
             // add should've been inserted from previous conditional statement
             assert(args.size() == 2);
-            return op::builder::add("gelu_split", *info.mod, {x}, {}).at(0);
+            return op::builder::add("gelu_split", *info.mod, {x}).at(0);
         }
 
         if(approximate == "tanh")
@@ -97,7 +97,7 @@ struct parse_gelu : op_parser<parse_gelu>
         }
         else
         {
-            return op::builder::add("gelu_erf", *info.mod, {x}, {}).at(0);
+            return op::builder::add("gelu_erf", *info.mod, {x}).at(0);
         }
     }
 };

src/onnx/parse_generic_op.cpp

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2024 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2025 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,8 +22,7 @@
  * THE SOFTWARE.
  */
 #include <migraphx/onnx/op_parser.hpp>
-#include <migraphx/ranges.hpp>
-#include <migraphx/make_op.hpp>
+#include <migraphx/op/builder/insert.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -72,24 +71,13 @@ struct parse_generic_op : op_parser<parse_generic_op>
         // clang-format on
     }
 
-    bool needs_contiguous(const std::string& op_name) const
-    {
-        return contains({"flatten", "gather", "scatter"}, op_name);
-    }
-
     instruction_ref parse(const op_desc& opd,
                           const onnx_parser& parser,
-                          onnx_parser::node_info info,
-                          std::vector<instruction_ref> args) const
+                          const onnx_parser::node_info& info,
+                          const std::vector<instruction_ref>& args) const
     {
-        auto op = parser.load(opd.op_name, info);
-        if(needs_contiguous(opd.op_name))
-        {
-            std::transform(args.begin(), args.end(), args.begin(), [&](auto arg) {
-                return info.make_contiguous(arg);
-            });
-        }
-        return info.add_instruction(op, args);
+        const auto& val = parser.load_to_value(opd.op_name, info);
+        return op::builder::add(opd.op_name, *info.mod, args, val).at(0);
     }
 };
 

src/onnx/parse_tile.cpp

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2025 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,9 +23,8 @@
  */
 #include <migraphx/onnx/op_parser.hpp>
 #include <migraphx/onnx/checks.hpp>
-#include <migraphx/ranges.hpp>
 #include <migraphx/instruction.hpp>
-#include <migraphx/make_op.hpp>
+#include <migraphx/op/builder/insert.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -45,16 +44,7 @@ struct parse_tile : op_parser<parse_tile>
         std::vector<std::int64_t> repeats;
         arg_s.visit([&](auto input) { repeats.assign(input.begin(), input.end()); });
 
-        auto l0 = args[0];
-        for(int i = 0; i < repeats.size(); i++)
-        {
-            auto l1 = l0;
-            for(int j = 1; j < repeats[i]; j++)
-            {
-                l0 = info.add_instruction(make_op("concat", {{"axis", i}}), l0, l1);
-            }
-        }
-        return l0;
+        return op::builder::add("tile", *info.mod, args, {{"repeats", repeats}}).at(0);
     }
 };
 

src/op/builder/clip.cpp

@@ -35,12 +35,6 @@ namespace builder {
 
 struct clip : op_builder<clip>
 {
-    template <class Self, class F>
-    static auto reflect(Self&, F)
-    {
-        return pack();
-    }
-
     std::vector<instruction_ref>
     insert(module& m, instruction_ref ins, const std::vector<instruction_ref>& args) const
     {

src/op/builder/gelu.cpp

@@ -57,12 +57,6 @@ struct gelu_quick : op_builder<gelu_quick>
 
 struct gelu_erf : op_builder<gelu_erf>
 {
-    template <class Self, class F>
-    static auto reflect(Self&, F)
-    {
-        return pack();
-    }
-
     std::vector<instruction_ref>
     insert(module& m, instruction_ref ins, const std::vector<instruction_ref>& args) const
     {
@@ -130,12 +124,6 @@ struct gelu_tanh : op_builder<gelu_tanh>
 
 struct gelu_split : op_builder<gelu_split>
 {
-    template <class Self, class F>
-    static auto reflect(Self&, F)
-    {
-        return pack();
-    }
-
     std::vector<instruction_ref>
     insert(module& m, instruction_ref ins, const std::vector<instruction_ref>& args) const
     {
@@ -155,7 +143,7 @@ struct gelu_split : op_builder<gelu_split>
                 {{"axes", {-1}}, {"starts", {last_dim_size / 2}}, {"ends", {last_dim_size}}}),
             x);
 
-        auto gelu_erf = op::builder::add("gelu_erf", m, {split_right}, {}).at(0);
+        auto gelu_erf = op::builder::add("gelu_erf", m, {split_right}).at(0);
         return {insert_common_op(m, ins, "mul", split_left, gelu_erf)};
     }
 };

src/op/builder/include/migraphx/op/builder/insert.hpp

@@ -35,29 +35,31 @@ inline namespace MIGRAPHX_INLINE_NS {
 namespace op {
 namespace builder {
 
+value get_default_options();
+
 MIGRAPHX_EXPORT std::vector<instruction_ref> insert(const std::string& name,
                                                     module& m,
                                                     instruction_ref ins,
                                                     const std::vector<instruction_ref>& args,
-                                                    const value& options);
+                                                    const value& options = get_default_options());
 
 MIGRAPHX_EXPORT std::vector<instruction_ref> insert(const std::string& name,
                                                     module& m,
                                                     instruction_ref ins,
                                                     const std::vector<instruction_ref>& args,
                                                     const std::vector<module_ref>& module_args,
-                                                    const value& options);
+                                                    const value& options = get_default_options());
 
 MIGRAPHX_EXPORT std::vector<instruction_ref> add(const std::string& name,
                                                  module& m,
                                                  const std::vector<instruction_ref>& args,
-                                                 const value& options);
+                                                 const value& options = get_default_options());
 
 MIGRAPHX_EXPORT std::vector<instruction_ref> add(const std::string& name,
                                                  module& m,
                                                  const std::vector<instruction_ref>& args,
                                                  const std::vector<module_ref>& module_args,
-                                                 const value& options);
+                                                 const value& options = get_default_options());
 template <class... Ins>
 instruction_ref
 insert_common_op(module& m, instruction_ref ins, const std::string& op_name, Ins... args)

src/op/builder/include/migraphx/op/builder/op_builder.hpp

@@ -46,7 +46,8 @@ using builder_func =
 MIGRAPHX_EXPORT void register_builder(const std::string& name, builder_func f);
 
 template <class T>
-auto invoke_builder(module& m,
+auto invoke_builder(const std::string& /*name*/,
+                    module& m,
                     instruction_ref ins,
                     const std::vector<instruction_ref>& args,
                     const std::vector<module_ref>& module_args,
@@ -57,7 +58,8 @@ auto invoke_builder(module& m,
 }
 
 template <class T>
-auto invoke_builder(module& m,
+auto invoke_builder(const std::string& /*name*/,
+                    module& m,
                     instruction_ref ins,
                     const std::vector<instruction_ref>& args,
                     const std::vector<module_ref>& module_args,
@@ -69,17 +71,46 @@ auto invoke_builder(module& m,
     return x.insert(m, ins, args);
 }
 
+template <class T>
+auto invoke_builder(const std::string& name,
+                    module& m,
+                    instruction_ref ins,
+                    const std::vector<instruction_ref>& args,
+                    const std::vector<module_ref>& module_args,
+                    const value& options) -> decltype(T{}.insert(name, m, ins, args, module_args))
+{
+    auto x = from_value<T>(options);
+    return x.insert(name, m, ins, args, module_args);
+}
+
+template <class T>
+auto invoke_builder(const std::string& name,
+                    module& m,
+                    instruction_ref ins,
+                    const std::vector<instruction_ref>& args,
+                    const std::vector<module_ref>& module_args,
+                    const value& options) -> decltype(T{}.insert(name, m, ins, args))
+{
+    if(not module_args.empty())
+        MIGRAPHX_THROW("Module args should be empty");
+    auto x = from_value<T>(options);
+    return x.insert(name, m, ins, args);
+}
+
 template <class T>
 void register_builder()
 {
-    builder_func f = [](module& m,
-                        instruction_ref ins,
-                        const std::vector<instruction_ref>& args,
-                        const std::vector<module_ref>& module_args,
-                        const value& options) {
-        return invoke_builder<T>(m, ins, args, module_args, options);
-    };
-    register_builder(T::name(), std::move(f));
+    for(const auto& name : T::names())
+    {
+        builder_func f = [=](module& m,
+                             instruction_ref ins,
+                             const std::vector<instruction_ref>& args,
+                             const std::vector<module_ref>& module_args,
+                             const value& options) {
+            return invoke_builder<T>(name, m, ins, args, module_args, options);
+        };
+        register_builder(name, std::move(f));
+    }
 }
 
 struct register_builder_action
@@ -94,10 +125,10 @@ struct register_builder_action
 template <class T>
 struct op_builder : auto_register<register_builder_action, T>
 {
-    static std::string name()
+    static std::vector<std::string> names()
     {
         static const std::string& name = get_type_name<T>();
-        return name.substr(name.rfind("::") + 2);
+        return {name.substr(name.rfind("::") + 2)};
     }
 };