manual merge

src/common_subexpression_elimination.cpp

-#include <migraph/common_subexpression_elimination.hpp>
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/ranges.hpp>
-#include <migraph/functional.hpp>
+#include <migraphx/common_subexpression_elimination.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/functional.hpp>
 
 #include <unordered_set>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 template <class Range>
 void cse_range(program& p, Range&& r)
@@ -35,5 +35,5 @@ void cse_range(program& p, Range&& r)
 
 void common_subexpression_elimination::apply(program& p) const { cse_range(p, iterator_for(p)); }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/constant_propagate.cpp

-#include <migraph/constant_propagate.hpp>
-#include <migraph/program.hpp>
-#include <migraph/matcher.hpp>
-#include <migraph/literal.hpp>
+#include <migraphx/constant_propagate.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/matcher.hpp>
+#include <migraphx/literal.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct match_const_add
 {
@@ -13,7 +13,7 @@ struct match_const_add
         return match::name("add")(match::args(match::name("@literal"), match::name("@literal")));
     }
 
-    void apply(program& p, match::matcher_result r) const
+    void apply(program& p, const match::matcher_result& r) const
     {
         auto ins  = r.result;
         auto arg1 = ins->inputs().at(0)->get_literal();
@@ -26,5 +26,5 @@ struct match_const_add
 
 void constant_propagate::apply(program& p) const { match::find_matches(p, match_const_add{}); }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/dead_code_elimination.cpp

-#include <migraph/dead_code_elimination.hpp>
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/functional.hpp>
-#include <migraph/ranges.hpp>
+#include <migraphx/dead_code_elimination.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/functional.hpp>
+#include <migraphx/ranges.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 template <class Range, class Iterator>
 std::ptrdiff_t bidistance(const Range& r, Iterator start, Iterator last)
@@ -62,5 +62,5 @@ void dead_code_elimination::apply(program& p) const
     p.remove_instructions(std::next(last), p.end());
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/eliminate_allocation.cpp

-#include <migraph/eliminate_allocation.hpp>
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/ranges.hpp>
-#include <migraph/stringutils.hpp>
-#include <migraph/pass_config.hpp>
+#include <migraphx/eliminate_allocation.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/pass_config.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 void eliminate_allocation::apply(program& p) const
 {
     assert(alignment > 0);
-    if(!enabled(MIGRAPH_DISABLE_MEMORY_COLORING{}))
-        return;
 
     std::size_t n = 0;
     std::vector<std::pair<instruction_ref, std::size_t>> allocs;
@@ -27,15 +25,18 @@ void eliminate_allocation::apply(program& p) const
         std::size_t padding = (alignment - (size % alignment)) % alignment;
         n += size + padding;
     }
-    auto mem = p.add_parameter("memory", shape{shape::int8_type, {n}});
-    for(auto&& pp : allocs)
+    if(n > 0)
     {
-        auto ins    = pp.first;
-        auto s      = ins->get_shape();
-        auto offset = pp.second;
-        p.replace_instruction(ins, op::load{s, offset}, mem);
+        auto mem = p.add_parameter("memory", shape{shape::int8_type, {n}});
+        for(auto&& pp : allocs)
+        {
+            auto ins    = pp.first;
+            auto s      = ins->get_shape();
+            auto offset = pp.second;
+            p.replace_instruction(ins, op::load{s, offset}, mem);
+        }
     }
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/eliminate_concat.cpp

 #include <iterator>
-#include <migraph/eliminate_concat.hpp>
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/dfor.hpp>
+#include <migraphx/eliminate_concat.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/dfor.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 void eliminate_concat::apply(program& p) const
 {
     for(auto ins : iterator_for(p))
@@ -36,14 +36,17 @@ void eliminate_concat::apply(program& p) const
             // Where are the allocations for the tensors to be concatenated?
             std::vector<instruction_ref> allocations;
 
-            for(auto ins2 = ins->inputs().begin(); ins2 != ins->inputs().end() - 1; ins2++)
-            {
-                auto last2 = (*ins2)->inputs().back();
-                if(last2->name() == concat_opt.allocate())
-                {
-                    allocations.push_back(last2);
-                }
-            }
+            std::transform(
+                ins->inputs().begin(),
+                std::prev(ins->inputs().end()),
+                std::back_inserter(allocations),
+                [&](instruction_ref x) { return instruction::get_output_alias(x, true); });
+
+            if(std::any_of(allocations.begin(), allocations.end(), [&](auto x) {
+                   return x->name() != concat_opt.allocate();
+               }))
+                continue;
+
             // Need to sort the allocations, so that we know where to
             // insert the "super"-allocation
             std::sort(
@@ -51,21 +54,21 @@ void eliminate_concat::apply(program& p) const
                     return std::distance(p.begin(), x) < std::distance(p.begin(), y);
                 });
             // Move "super" allocation to the front
-            auto first         = allocations.front();
-            auto super         = p.move_instruction(last, first);
+            auto first = allocations.front();
+            auto super = p.move_instruction(last, first);
+            // Replace each allocation with a load
             std::size_t offset = 0;
-            for(auto x : allocations)
+            for(auto alloc : allocations)
             {
-                migraph::op::load op{x->get_shape(), offset};
-                // migraph::op::load op{x->get_shape(), 0};
-                p.replace_instruction(x, op, {super});
-                offset += x->get_shape().bytes();
+                op::load op{alloc->get_shape(), offset};
+                p.replace_instruction(alloc, op, {super});
+                offset += alloc->get_shape().bytes();
             }
             std::vector<instruction_ref> args = {super};
             std::copy(ins->inputs().begin(), ins->inputs().end() - 1, std::back_inserter(args));
-            p.replace_instruction(ins, migraph::op::identity{}, args);
+            p.replace_instruction(ins, migraphx::op::identity{}, args);
         }
     }
 }
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/eliminate_contiguous.cpp

-#include <migraph/eliminate_contiguous.hpp>
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/ranges.hpp>
-#include <migraph/stringutils.hpp>
+#include <migraphx/eliminate_contiguous.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/stringutils.hpp>
 #include <utility>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 bool try_compute_shape(const operation& op, const std::vector<instruction_ref>& args)
 {
@@ -47,5 +47,5 @@ void eliminate_contiguous::apply(program& p) const
     }
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/env.cpp

-#include <migraph/env.hpp>
-#include <migraph/ranges.hpp>
+#include <migraphx/env.hpp>
+#include <migraphx/ranges.hpp>
 #include <cstdlib>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 bool enabled(const char* name)
 {
@@ -30,5 +30,5 @@ std::vector<std::string> env(const char* name)
         return {{p}};
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/fwd_conv_batchnorm_rewrite.cpp

-#include <migraph/fwd_conv_batchnorm_rewrite.hpp>
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/dfor.hpp>
+#include <migraphx/fwd_conv_batchnorm_rewrite.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/dfor.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 void fwd_conv_batchnorm_rewrite::apply(program& p) const
 {
@@ -67,5 +67,5 @@ void fwd_conv_batchnorm_rewrite::apply(program& p) const
     }
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/generate.cpp

-#include <migraph/generate.hpp>
+#include <migraphx/generate.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 argument generate_argument(shape s, unsigned long seed)
 {
@@ -31,5 +31,5 @@ literal abs(literal l)
     return transform(std::move(l), [](auto x) { return std::fabs(x); });
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/include/migraph/config.hpp

-#ifndef MIGRAPH_GUARD_CONFIG_HPP
-#define MIGRAPH_GUARD_CONFIG_HPP
-
-namespace migraph {
-
-#if !defined(MIGRAPH_USE_CLANG_TIDY) && !defined(DOXYGEN)
-#define MIGRAPH_INLINE_NS version_1
-#endif
-
-} // namespace migraph
-
-#endif

src/include/migraph/fallthrough.hpp

-#ifndef MIGRAPH_GUARD_FALLTHROUGH_HPP
-#define MIGRAPH_GUARD_FALLTHROUGH_HPP
-
-#include <migraph/config.hpp>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-
-#ifdef __clang__
-#define MIGRAPH_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define MIGRAPH_FALLTHROUGH
-#endif
-
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-
-#endif

src/include/migraph/onnx.hpp

-#ifndef MIGRAPH_GUARD_MIGRAPHLIB_ONNX_HPP
-#define MIGRAPH_GUARD_MIGRAPHLIB_ONNX_HPP
-
-#include <migraph/program.hpp>
-#include <migraph/config.hpp>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-
-/// Create a program from an onnx file
-program parse_onnx(const std::string& name);
-
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-
-#endif

src/include/migraph/pass_config.hpp

-
-#ifndef MIGRAPH_GUARD_PASS_CONFIG_HPP
-#define MIGRAPH_GUARD_PASS_CONFIG_HPP
-
-#include <migraph/env.hpp>
-#include <migraph/config.hpp>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-
-MIGRAPH_DECLARE_ENV_VAR(MIGRAPH_DISABLE_MEMORY_COLORING)
-
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-#endif // MIGRAPH_GUARD_PASS_CONFIG_HPP

src/include/migraph/rank.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_RANK_HPP
-#define MIGRAPH_GUARD_RTGLIB_RANK_HPP
-
-#include <migraph/config.hpp>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-
-template <int N>
-struct rank : rank<N - 1>
-{
-};
-
-template <>
-struct rank<0>
-{
-};
-
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-
-#endif

src/include/migraph/argument.hpp → src/include/migraphx/argument.hpp

-#ifndef MIGRAPH_GUARD_MIGRAPHLIB_ARGUMENT_HPP
-#define MIGRAPH_GUARD_MIGRAPHLIB_ARGUMENT_HPP
+#ifndef MIGRAPHX_GUARD_MIGRAPHLIB_ARGUMENT_HPP
+#define MIGRAPHX_GUARD_MIGRAPHLIB_ARGUMENT_HPP
 
-#include <migraph/shape.hpp>
-#include <migraph/raw_data.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/shape.hpp>
+#include <migraphx/raw_data.hpp>
+#include <migraphx/config.hpp>
 #include <functional>
 #include <utility>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 /**
  * @brief Arguments passed to instructions
@@ -47,7 +47,7 @@ struct argument : raw_data<argument>
     shape m_shape;
 };
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/include/migraph/auto_any_cast.hpp → src/include/migraphx/auto_any_cast.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_AUTO_ANY_CAST_HPP
-#define MIGRAPH_GUARD_RTGLIB_AUTO_ANY_CAST_HPP
-#include <migraph/config.hpp>
+#ifndef MIGRAPHX_GUARD_RTGLIB_AUTO_ANY_CAST_HPP
+#define MIGRAPHX_GUARD_RTGLIB_AUTO_ANY_CAST_HPP
+#include <migraphx/config.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 namespace detail {
 
@@ -34,7 +34,7 @@ detail::auto_any_caster<T> auto_any_cast(T& x)
     return {x};
 }
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/include/migraph/auto_contiguous.hpp → src/include/migraphx/auto_contiguous.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
-#define MIGRAPH_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
 
 #include <string>
-#include <migraph/instruction_ref.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/instruction_ref.hpp>
+#include <migraphx/config.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -16,7 +16,7 @@ struct auto_contiguous
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/include/migraph/builtin.hpp → src/include/migraphx/builtin.hpp

-#ifndef MIGRAPH_GUARD_BUILTIN_HPP
-#define MIGRAPH_GUARD_BUILTIN_HPP
+#ifndef MIGRAPHX_GUARD_BUILTIN_HPP
+#define MIGRAPHX_GUARD_BUILTIN_HPP
 
-#include <migraph/context.hpp>
-#include <migraph/errors.hpp>
-#include <migraph/argument.hpp>
-#include <migraph/reflect.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/context.hpp>
+#include <migraphx/errors.hpp>
+#include <migraphx/argument.hpp>
+#include <migraphx/reflect.hpp>
+#include <migraphx/config.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 namespace builtin {
 
 struct literal
 {
     std::string name() const { return "@literal"; }
-    shape compute_shape(const std::vector<shape>&) const { MIGRAPH_THROW("builtin"); }
+    shape compute_shape(const std::vector<shape>&) const { MIGRAPHX_THROW("builtin"); }
     argument compute(context&, const shape&, const std::vector<argument>&) const
     {
-        MIGRAPH_THROW("builtin");
+        MIGRAPHX_THROW("builtin");
     }
 };
 
@@ -36,7 +36,7 @@ struct outline
     shape compute_shape(const std::vector<shape>&) const { return s; }
     argument compute(context&, const shape&, const std::vector<argument>&) const
     {
-        MIGRAPH_THROW("builtin");
+        MIGRAPHX_THROW("builtin");
     }
 };
 
@@ -51,10 +51,10 @@ struct param
     }
 
     std::string name() const { return "@param"; }
-    shape compute_shape(const std::vector<shape>&) const { MIGRAPH_THROW("builtin"); }
+    shape compute_shape(const std::vector<shape>&) const { MIGRAPHX_THROW("builtin"); }
     argument compute(context&, const shape&, const std::vector<argument>&) const
     {
-        MIGRAPH_THROW("builtin");
+        MIGRAPHX_THROW("builtin");
     }
     friend std::ostream& operator<<(std::ostream& os, const param& op)
     {
@@ -64,7 +64,7 @@ struct param
 };
 
 } // namespace builtin
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/include/migraph/check_context.hpp → src/include/migraphx/check_context.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CHECK_CONTEXT_HPP
-#define MIGRAPH_GUARD_RTGLIB_CHECK_CONTEXT_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CHECK_CONTEXT_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CHECK_CONTEXT_HPP
 
-#include <migraph/program.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/config.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 template <class T>
 struct check_context
@@ -15,11 +15,19 @@ struct check_context
         std::string name() const { return "check_context"; }
         shape compute_shape(const std::vector<shape>&) const { return {}; }
         argument compute(context& ctx, const shape&, const std::vector<argument>&) const
+        {
+            this->check(ctx);
+            return {};
+        }
+        void finalize(context& ctx, const shape&, const std::vector<shape>&) const
+        {
+            this->check(ctx);
+        }
+        void check(context& ctx) const
         {
             T* x = any_cast<T>(&ctx);
             if(x == nullptr)
-                MIGRAPH_THROW(std::string("Unexpected context type: ") + ctx.type_id().name());
-            return {};
+                MIGRAPHX_THROW(std::string("Unexpected context type: ") + ctx.type_id().name());
         }
     };
 
@@ -27,7 +35,7 @@ struct check_context
     void apply(program& p) const { p.insert_instruction(p.begin(), op{}); }
 };
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/include/migraph/check_shapes.hpp → src/include/migraphx/check_shapes.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CHECK_SHAPES_HPP
-#define MIGRAPH_GUARD_RTGLIB_CHECK_SHAPES_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CHECK_SHAPES_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CHECK_SHAPES_HPP
 
-#include <migraph/shape.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/shape.hpp>
+#include <migraphx/config.hpp>
 #include <algorithm>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct check_shapes
 {
@@ -46,8 +46,8 @@ struct check_shapes
     const check_shapes& has(std::size_t n) const
     {
         if(size() != n)
-            MIGRAPH_THROW(prefix() + "Wrong number of arguments: expected " + std::to_string(n) +
-                          " but given " + std::to_string(size()));
+            MIGRAPHX_THROW(prefix() + "Wrong number of arguments: expected " + std::to_string(n) +
+                           " but given " + std::to_string(size()));
         return *this;
     }
 
@@ -58,7 +58,7 @@ struct check_shapes
         if(begin != end)
         {
             if(begin->lens().size() != n)
-                MIGRAPH_THROW(prefix() + "Only " + std::to_string(n) + "d supported");
+                MIGRAPHX_THROW(prefix() + "Only " + std::to_string(n) + "d supported");
         }
         return *this;
     }
@@ -66,56 +66,56 @@ struct check_shapes
     const check_shapes& same_shape() const
     {
         if(!this->same([](const shape& s) { return s; }))
-            MIGRAPH_THROW(prefix() + "Shapes do not match");
+            MIGRAPHX_THROW(prefix() + "Shapes do not match");
         return *this;
     }
 
     const check_shapes& same_type() const
     {
         if(!this->same([](const shape& s) { return s.type(); }))
-            MIGRAPH_THROW(prefix() + "Types do not match");
+            MIGRAPHX_THROW(prefix() + "Types do not match");
         return *this;
     }
 
     const check_shapes& same_dims() const
     {
         if(!this->same([](const shape& s) { return s.lens(); }))
-            MIGRAPH_THROW(prefix() + "Dimensions do not match");
+            MIGRAPHX_THROW(prefix() + "Dimensions do not match");
         return *this;
     }
 
     const check_shapes& same_ndims() const
     {
         if(!this->same([](const shape& s) { return s.lens().size(); }))
-            MIGRAPH_THROW(prefix() + "Number of dimensions do not match");
+            MIGRAPHX_THROW(prefix() + "Number of dimensions do not match");
         return *this;
     }
 
     const check_shapes& standard() const
     {
         if(!this->all_of([](const shape& s) { return s.standard(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are not in standard layout");
+            MIGRAPHX_THROW(prefix() + "Shapes are not in standard layout");
         return *this;
     }
 
     const check_shapes& packed() const
     {
         if(!this->all_of([](const shape& s) { return s.packed(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are not packed");
+            MIGRAPHX_THROW(prefix() + "Shapes are not packed");
         return *this;
     }
 
     const check_shapes& not_transposed() const
     {
         if(!this->all_of([](const shape& s) { return not s.transposed(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are transposed");
+            MIGRAPHX_THROW(prefix() + "Shapes are transposed");
         return *this;
     }
 
     const check_shapes& not_broadcasted() const
     {
         if(!this->all_of([](const shape& s) { return not s.broadcasted(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are broadcasted");
+            MIGRAPHX_THROW(prefix() + "Shapes are broadcasted");
         return *this;
     }
 
@@ -143,7 +143,7 @@ struct check_shapes
     const shape* get(long i)
     {
         if(i >= size())
-            MIGRAPH_THROW(prefix() + "Accessing shape out of bounds");
+            MIGRAPHX_THROW(prefix() + "Accessing shape out of bounds");
         assert(begin != nullptr);
         assert(end != nullptr);
         if(i < 0)
@@ -156,7 +156,7 @@ struct check_shapes
     check_shapes slice(long start, long last) { return {get(start), get(last), name}; }
 };
 
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif