manual merge

d2549384 · Khalique · 67048d04 · ab6cd9d3 · d2549384 · d2549384
Commit d2549384 authored Feb 01, 2019 by Khalique
20 changed files
--- a/test/onnx/slice_test.onnx
+++ b/test/onnx/slice_test.onnx
--- a/test/onnx/softmax_test.onnx
+++ b/test/onnx/softmax_test.onnx
+softmax-example:I
+
+01"Softmaxtest-softmaxZ
+0
+
+
+b
+1
+
+
+B
\ No newline at end of file
--- a/test/onnx/squeeze_unsqueeze_test.onnx
+++ b/test/onnx/squeeze_unsqueeze_test.onnx
--- a/test/onnx/sum_test.onnx
+++ b/test/onnx/sum_test.onnx
+sum-example:e
+
+0
+1
+23"Sumtest-dropoutZ
+0
+
+
+Z
+1
+
+
+Z
+2
+
+
+b
+2
+
+
+B
\ No newline at end of file
--- a/test/onnx/tan_test.onnx
+++ b/test/onnx/tan_test.onnx
+tan-example:9
+
+xy"Tantest_tanZ
+x
+
+
+
+b
+y
+
+
+
+B
\ No newline at end of file
--- a/test/onnx/tanh_test.onnx
+++ b/test/onnx/tanh_test.onnx
+tanh-example:;
+
+xy"Tanh	test_tanhZ
+x
+
+
+b
+y
+
+
+B
\ No newline at end of file
--- a/test/onnx/unknown_test.onnx
+++ b/test/onnx/unknown_test.onnx
+unknown-example:
+
+0
+12"Unknown
+
+2"Unknowntest-unknownZ
+0
+
+
+
+
+Z
+1
+
+
+b
+2
+
+
+
+
+B
\ No newline at end of file
--- a/test/op_shape_test.cpp
+++ b/test/op_shape_test.cpp
-#include <migraph/program.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
 #include <sstream>
 #include "test.hpp"

 template <class... Ts>
-void expect_shape(const migraph::shape& expected, const migraph::operation& op, Ts... xs)
+void expect_shape(const migraphx::shape& expected, const migraphx::operation& op, Ts... xs)
 {
-    migraph::program p;
-    std::vector<migraph::shape> shapes{xs...};
-    std::vector<migraph::instruction_ref> args(shapes.size());
+    migraphx::program p;
+    std::vector<migraphx::shape> shapes{xs...};
+    std::vector<migraphx::instruction_ref> args(shapes.size());
    std::transform(
        shapes.begin(), shapes.end(), args.begin(), [&](auto&& s) { return p.add_outline(s); });
    p.add_instruction(op, args);
@@ -24,11 +24,11 @@ void expect_shape(const migraph::shape& expected, const migraph::operation& op,
 }

 template <class... Ts>
-void throws_shape(const migraph::operation& op, Ts... xs)
+void throws_shape(const migraphx::operation& op, Ts... xs)
 {
-    migraph::program p;
-    std::vector<migraph::shape> shapes{xs...};
-    std::vector<migraph::instruction_ref> args(shapes.size());
+    migraphx::program p;
+    std::vector<migraphx::shape> shapes{xs...};
+    std::vector<migraphx::instruction_ref> args(shapes.size());
    std::transform(
        shapes.begin(), shapes.end(), args.begin(), [&](auto&& s) { return p.add_outline(s); });
    bool thrown = test::throws([&] { p.add_instruction(op, args); });
@@ -46,7 +46,7 @@ struct always_false : std::false_type
 };

 template <class... Ts>
-void throws_shape(const migraph::shape&, Ts...)
+void throws_shape(const migraphx::shape&, Ts...)
 {
    static_assert(always_false<Ts...>{},
                  "An expected shape should not be passed to throws_shape function");
@@ -55,94 +55,97 @@ void throws_shape(const migraph::shape&, Ts...)
 TEST_CASE(batch_norm_inference_shape)
 {
    const size_t channels = 3;
-    migraph::shape s{migraph::shape::float_type, {4, channels, 3, 3}};
-    migraph::shape vars{migraph::shape::float_type, {channels}};
-    expect_shape(s, migraph::op::batch_norm_inference{}, s, vars, vars, vars, vars);
-    throws_shape(migraph::op::batch_norm_inference{}, s);
-    throws_shape(migraph::op::batch_norm_inference{}, s, vars, vars, vars, vars, vars);
+    migraphx::shape s{migraphx::shape::float_type, {4, channels, 3, 3}};
+    migraphx::shape vars{migraphx::shape::float_type, {channels}};
+    expect_shape(s, migraphx::op::batch_norm_inference{}, s, vars, vars, vars, vars);
+    throws_shape(migraphx::op::batch_norm_inference{}, s);
+    throws_shape(migraphx::op::batch_norm_inference{}, s, vars, vars, vars, vars, vars);
 }

 TEST_CASE(convolution_shape)
 {
-    migraph::shape output{migraph::shape::float_type, {4, 4, 1, 1}};
-    migraph::shape input{migraph::shape::float_type, {4, 3, 3, 3}};
-    migraph::shape weights{migraph::shape::float_type, {4, 3, 3, 3}};
-    expect_shape(output, migraph::op::convolution{}, input, weights);
-    throws_shape(migraph::op::convolution{}, input);
-
-    migraph::shape input2{migraph::shape::float_type, {3, 3}};
-    migraph::shape weights2{migraph::shape::float_type, {3, 3}};
-    throws_shape(migraph::op::convolution{}, input2, weights2);
-    throws_shape(migraph::op::convolution{}, input2, weights);
+    migraphx::shape output{migraphx::shape::float_type, {4, 4, 1, 1}};
+    migraphx::shape input{migraphx::shape::float_type, {4, 3, 3, 3}};
+    migraphx::shape weights{migraphx::shape::float_type, {4, 3, 3, 3}};
+    expect_shape(output, migraphx::op::convolution{}, input, weights);
+    throws_shape(migraphx::op::convolution{}, input);
+
+    migraphx::shape input2{migraphx::shape::float_type, {3, 3}};
+    migraphx::shape weights2{migraphx::shape::float_type, {3, 3}};
+    throws_shape(migraphx::op::convolution{}, input2, weights2);
+    throws_shape(migraphx::op::convolution{}, input2, weights);
 }

 TEST_CASE(transpose_shape)
 {
-    migraph::shape input{migraph::shape::float_type, {2, 2}};
-    migraph::shape output{migraph::shape::float_type, {2, 2}, {1, 2}};
-    expect_shape(input, migraph::op::transpose{{0, 1}}, input);
-    expect_shape(output, migraph::op::transpose{{1, 0}}, input);
-    throws_shape(migraph::op::transpose{{1, 2}}, input);
+    migraphx::shape input{migraphx::shape::float_type, {2, 2}};
+    migraphx::shape output{migraphx::shape::float_type, {2, 2}, {1, 2}};
+    expect_shape(input, migraphx::op::transpose{{0, 1}}, input);
+    expect_shape(output, migraphx::op::transpose{{1, 0}}, input);
+    throws_shape(migraphx::op::transpose{{1, 2}}, input);
 }

 TEST_CASE(contiguous_shape)
 {
-    migraph::shape output{migraph::shape::float_type, {2, 2}};
-    migraph::shape input{migraph::shape::float_type, {2, 2}, {1, 2}};
-    expect_shape(output, migraph::op::contiguous{}, input);
-    throws_shape(migraph::op::contiguous{}, input, input);
+    migraphx::shape output{migraphx::shape::float_type, {2, 2}};
+    migraphx::shape input{migraphx::shape::float_type, {2, 2}, {1, 2}};
+    expect_shape(output, migraphx::op::contiguous{}, input);
+    throws_shape(migraphx::op::contiguous{}, input, input);

-    migraph::shape single{migraph::shape::float_type, {2}};
-    expect_shape(single, migraph::op::contiguous{}, single);
+    migraphx::shape single{migraphx::shape::float_type, {2}};
+    expect_shape(single, migraphx::op::contiguous{}, single);
 }

 TEST_CASE(reshape_shape)
 {
-    migraph::shape input{migraph::shape::float_type, {24, 1, 1, 1}};
+    migraphx::shape input{migraphx::shape::float_type, {24, 1, 1, 1}};
    for(auto&& new_shape :
        std::vector<std::vector<int64_t>>{{8, 3, 1, 1}, {1, 3, 4, 2}, {1, 3, 4, 2}})
    {
        std::vector<std::size_t> lens(new_shape.size());
        std::copy(new_shape.begin(), new_shape.end(), lens.begin());
-        migraph::shape output{migraph::shape::float_type, lens};
-        expect_shape(output, migraph::op::reshape{new_shape}, input);
+        migraphx::shape output{migraphx::shape::float_type, lens};
+        expect_shape(output, migraphx::op::reshape{new_shape}, input);
    }

    for(auto&& new_shape : std::vector<std::vector<int64_t>>{{8, 3, 2, 2}, {1, 3, -1, -1}})
    {
-        throws_shape(migraph::op::reshape{new_shape}, input);
+        throws_shape(migraphx::op::reshape{new_shape}, input);
    }
 }

 TEST_CASE(flatten_shape)
 {
-    migraph::shape input{migraph::shape::float_type, {2, 4, 6, 8}};
-    expect_shape(migraph::shape{migraph::shape::float_type, {1, 2 * 4 * 6 * 8}},
-                 migraph::op::flatten{0},
+    migraphx::shape input{migraphx::shape::float_type, {2, 4, 6, 8}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {1, 2 * 4 * 6 * 8}},
+                 migraphx::op::flatten{0},
                 input);
-    expect_shape(
-        migraph::shape{migraph::shape::float_type, {2, 4 * 6 * 8}}, migraph::op::flatten{1}, input);
-    expect_shape(
-        migraph::shape{migraph::shape::float_type, {2 * 4, 6 * 8}}, migraph::op::flatten{2}, input);
-    expect_shape(
-        migraph::shape{migraph::shape::float_type, {2 * 4 * 6, 8}}, migraph::op::flatten{3}, input);
-    expect_shape(migraph::shape{migraph::shape::float_type, {2 * 4 * 6 * 8, 1}},
-                 migraph::op::flatten{4},
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {2, 4 * 6 * 8}},
+                 migraphx::op::flatten{1},
                 input);
-    throws_shape(migraph::op::flatten{5}, input);
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {2 * 4, 6 * 8}},
+                 migraphx::op::flatten{2},
+                 input);
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {2 * 4 * 6, 8}},
+                 migraphx::op::flatten{3},
+                 input);
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {2 * 4 * 6 * 8, 1}},
+                 migraphx::op::flatten{4},
+                 input);
+    throws_shape(migraphx::op::flatten{5}, input);
 }

 TEST_CASE(slice_shape)
 {
-    migraph::shape input{migraph::shape::int32_type, {2, 2, 3}};
-    expect_shape(migraph::shape{migraph::shape::int32_type, {2, 2, 2}, {6, 3, 1}},
-                 migraph::op::slice{{2}, {1}, {3}},
+    migraphx::shape input{migraphx::shape::int32_type, {2, 2, 3}};
+    expect_shape(migraphx::shape{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}},
+                 migraphx::op::slice{{2}, {1}, {3}},
                 input);
-    expect_shape(migraph::shape{migraph::shape::int32_type, {2, 2, 2}, {6, 3, 1}},
-                 migraph::op::slice{{0, 1, 2}, {0, 0, 1}, {2, 2, 3}},
+    expect_shape(migraphx::shape{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}},
+                 migraphx::op::slice{{0, 1, 2}, {0, 0, 1}, {2, 2, 3}},
                 input);
-    expect_shape(migraph::shape{migraph::shape::int32_type, {2, 2, 1}, {6, 3, 1}},
-                 migraph::op::slice{{2}, {2}, {10}},
+    expect_shape(migraphx::shape{migraphx::shape::int32_type, {2, 2, 1}, {6, 3, 1}},
+                 migraphx::op::slice{{2}, {2}, {10}},
                 input);
 }

@@ -150,62 +153,99 @@ TEST_CASE(multibroadcast)
 {
    {
        std::vector<std::size_t> lens{4, 2, 5, 3};
-        migraph::shape input{migraph::shape::float_type, {2, 1, 3}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {0, 3, 0, 1}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {2, 1, 3}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {0, 3, 0, 1}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 2, 5, 3};
-        migraph::shape input{migraph::shape::float_type, {2, 1, 1}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {0, 1, 0, 0}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {2, 1, 1}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {0, 1, 0, 0}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 2, 5, 3};
-        migraph::shape input{migraph::shape::float_type, {5, 1}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {0, 0, 1, 0}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {5, 1}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {0, 0, 1, 0}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 2, 5, 3};
-        migraph::shape input{migraph::shape::float_type, {4, 1, 1, 1}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {1, 0, 0, 0}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {4, 1, 1, 1}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {1, 0, 0, 0}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 2, 5, 3};
-        migraph::shape input{migraph::shape::float_type, {3}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {0, 0, 0, 1}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {3}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {0, 0, 0, 1}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 4, 1, 3};
-        migraph::shape input{migraph::shape::float_type, {4, 1, 3}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {0, 3, 3, 1}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {4, 1, 3}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {0, 3, 3, 1}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 1, 1, 3};
-        migraph::shape input{migraph::shape::float_type, {4, 1, 1, 1}};
-        expect_shape(migraph::shape{migraph::shape::float_type, lens, {1, 1, 1, 0}},
-                     migraph::op::multibroadcast{lens},
+        migraphx::shape input{migraphx::shape::float_type, {4, 1, 1, 1}};
+        expect_shape(migraphx::shape{migraphx::shape::float_type, lens, {1, 1, 1, 0}},
+                     migraphx::op::multibroadcast{lens},
                     input);
    }
    {
        std::vector<std::size_t> lens{4, 1, 3};
-        migraph::shape input{migraph::shape::float_type, {4, 1, 1, 1}};
-        throws_shape(migraph::op::multibroadcast{lens}, input);
+        migraphx::shape input{migraphx::shape::float_type, {4, 1, 1, 1}};
+        throws_shape(migraphx::op::multibroadcast{lens}, input);
    }
    {
        std::vector<std::size_t> lens{4, 1, 3};
-        migraph::shape input{migraph::shape::float_type, {}};
-        throws_shape(migraph::op::multibroadcast{lens}, input);
+        migraphx::shape input{migraphx::shape::float_type, {}};
+        throws_shape(migraphx::op::multibroadcast{lens}, input);
+    }
+}
+
+TEST_CASE(gather)
+{
+    {
+        migraphx::shape input{migraphx::shape::float_type, {2, 3, 4, 5}};
+        migraphx::shape indices{migraphx::shape::int32_type, {2, 3}};
+        int axis = 1;
+        expect_shape(migraphx::shape{migraphx::shape::float_type, {2, 6, 4, 5}},
+                     migraphx::op::gather{axis},
+                     input,
+                     indices);
+    }
+
+    {
+        migraphx::shape input{migraphx::shape::float_type, {2, 3, 4, 5}};
+        migraphx::shape indices{migraphx::shape::int32_type, {2, 3}};
+        int axis = -4;
+        expect_shape(migraphx::shape{migraphx::shape::float_type, {6, 3, 4, 5}},
+                     migraphx::op::gather{axis},
+                     input,
+                     indices);
+    }
+
+    {
+        migraphx::shape input{migraphx::shape::float_type, {2, 3, 4, 5}};
+        migraphx::shape indices{migraphx::shape::int32_type, {2, 3}};
+        int axis = 4;
+        throws_shape(migraphx::op::gather{axis}, input, indices);
+    }
+
+    {
+        migraphx::shape input{migraphx::shape::float_type, {2, 3, 4, 5}};
+        migraphx::shape indices{migraphx::shape::int32_type, {2, 3}};
+        int axis = -5;
+        throws_shape(migraphx::op::gather{axis}, input, indices);
    }
 }


--- a/test/operation.cpp
+++ b/test/operation.cpp

-#include <migraph/operation.hpp>
+#include <migraphx/operation.hpp>
 #include <sstream>
 #include <string>
 #include "test.hpp"
@@ -9,18 +9,19 @@ struct simple_operation
    template <class T, class F>
    static auto reflect(T& x, F f)
    {
-        return migraph::pack(f(x.data, "data"));
+        return migraphx::pack(f(x.data, "data"));
    }
    int data = 1;
    std::string name() const { return "simple"; }
-    migraph::shape compute_shape(const std::vector<migraph::shape>&) const
+    migraphx::shape compute_shape(const std::vector<migraphx::shape>&) const
    {
-        MIGRAPH_THROW("not computable");
+        MIGRAPHX_THROW("not computable");
    }
-    migraph::argument
-    compute(migraph::context&, const migraph::shape&, const std::vector<migraph::argument>&) const
+    migraphx::argument compute(migraphx::context&,
+                               const migraphx::shape&,
+                               const std::vector<migraphx::argument>&) const
    {
-        MIGRAPH_THROW("not computable");
+        MIGRAPHX_THROW("not computable");
    }
    friend std::ostream& operator<<(std::ostream& os, const simple_operation& op)
    {
@@ -32,22 +33,23 @@ struct simple_operation
 struct simple_operation_no_print
 {
    std::string name() const { return "simple"; }
-    migraph::shape compute_shape(const std::vector<migraph::shape>&) const
+    migraphx::shape compute_shape(const std::vector<migraphx::shape>&) const
    {
-        MIGRAPH_THROW("not computable");
+        MIGRAPHX_THROW("not computable");
    }
-    migraph::argument
-    compute(migraph::context&, const migraph::shape&, const std::vector<migraph::argument>&) const
+    migraphx::argument compute(migraphx::context&,
+                               const migraphx::shape&,
+                               const std::vector<migraphx::argument>&) const
    {
-        MIGRAPH_THROW("not computable");
+        MIGRAPHX_THROW("not computable");
    }
 };

 TEST_CASE(operation_copy_test)
 {
    simple_operation s{};
-    migraph::operation op1 = s;   // NOLINT
-    migraph::operation op2 = op1; // NOLINT
+    migraphx::operation op1 = s;   // NOLINT
+    migraphx::operation op2 = op1; // NOLINT
    // cppcheck-suppress duplicateExpression
    EXPECT(s == op1);
    // cppcheck-suppress duplicateExpression
@@ -57,10 +59,10 @@ TEST_CASE(operation_copy_test)
 TEST_CASE(operation_equal_test)
 {
    simple_operation s{};
-    migraph::operation op1 = s;
-    s.data                 = 2;
-    migraph::operation op2 = op1; // NOLINT
-    migraph::operation op3 = s;   // NOLINT
+    migraphx::operation op1 = s;
+    s.data                  = 2;
+    migraphx::operation op2 = op1; // NOLINT
+    migraphx::operation op3 = s;   // NOLINT

    EXPECT(s != op1);
    EXPECT(op2 == op1);
@@ -74,18 +76,18 @@ struct not_operation

 TEST_CASE(operation_any_cast)
 {
-    migraph::operation op1 = simple_operation{};
-    EXPECT(migraph::any_cast<simple_operation>(op1).data == 1);
-    EXPECT(migraph::any_cast<not_operation*>(&op1) == nullptr);
-    EXPECT(test::throws([&] { migraph::any_cast<not_operation&>(op1); }));
-    migraph::operation op2 = simple_operation{2};
-    EXPECT(migraph::any_cast<simple_operation>(op2).data == 2);
-    EXPECT(migraph::any_cast<not_operation*>(&op2) == nullptr);
+    migraphx::operation op1 = simple_operation{};
+    EXPECT(migraphx::any_cast<simple_operation>(op1).data == 1);
+    EXPECT(migraphx::any_cast<not_operation*>(&op1) == nullptr);
+    EXPECT(test::throws([&] { migraphx::any_cast<not_operation&>(op1); }));
+    migraphx::operation op2 = simple_operation{2};
+    EXPECT(migraphx::any_cast<simple_operation>(op2).data == 2);
+    EXPECT(migraphx::any_cast<not_operation*>(&op2) == nullptr);
 }

 TEST_CASE(operation_print)
 {
-    migraph::operation op = simple_operation{};
+    migraphx::operation op = simple_operation{};
    std::stringstream ss;
    ss << op;
    std::string s = ss.str();
@@ -94,11 +96,71 @@ TEST_CASE(operation_print)

 TEST_CASE(operation_default_print)
 {
-    migraph::operation op = simple_operation_no_print{};
+    migraphx::operation op = simple_operation_no_print{};
    std::stringstream ss;
    ss << op;
    std::string s = ss.str();
    EXPECT(s == "simple");
 }

+struct final_operation
+{
+    std::string name() const { return "final"; }
+    migraphx::shape compute_shape(const std::vector<migraphx::shape>&) const
+    {
+        MIGRAPHX_THROW("not computable");
+    }
+    void
+    finalize(migraphx::context&, const migraphx::shape&, const std::vector<migraphx::shape>&) const
+    {
+    }
+};
+
+struct final_operation_throw
+{
+    std::string name() const { return "final"; }
+    migraphx::shape compute_shape(const std::vector<migraphx::shape>&) const
+    {
+        MIGRAPHX_THROW("not computable");
+    }
+    [[gnu::noreturn]] void
+    finalize(migraphx::context&, const migraphx::shape&, const std::vector<migraphx::shape>&) const
+    {
+        MIGRAPHX_THROW("finalize");
+    }
+};
+
+TEST_CASE(check_has_finalize_simple)
+{
+    migraphx::operation op = simple_operation{};
+    EXPECT(not migraphx::has_finalize(op));
+}
+
+TEST_CASE(check_has_finalize)
+{
+    migraphx::operation op = final_operation{};
+    EXPECT(migraphx::has_finalize(op));
+}
+
+TEST_CASE(check_run_finalize)
+{
+    migraphx::operation op = final_operation{};
+    migraphx::context ctx{};
+    op.finalize(ctx, {}, {});
+}
+
+TEST_CASE(check_run_finalize_simple)
+{
+    migraphx::operation op = simple_operation{};
+    migraphx::context ctx{};
+    op.finalize(ctx, {}, {});
+}
+
+TEST_CASE(check_run_finalize_throw)
+{
+    migraphx::operation op = final_operation_throw{};
+    migraphx::context ctx{};
+    EXPECT(test::throws([&] { op.finalize(ctx, {}, {}); }));
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }
--- a/test/output_alias.cpp
+++ b/test/output_alias.cpp
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
 #include <test.hpp>
 #include <basic_ops.hpp>

 TEST_CASE(simple_alias)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(1);
    auto p1 = p.add_instruction(pass_op{}, l);
-    EXPECT(bool{migraph::instruction::get_output_alias(l) == l});
-    EXPECT(bool{migraph::instruction::get_output_alias(p1) == l});
+    EXPECT(bool{migraphx::instruction::get_output_alias(l) == l});
+    EXPECT(bool{migraphx::instruction::get_output_alias(p1) == l});
 }

 TEST_CASE(cascade_alias)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(1);
    auto p1 = p.add_instruction(pass_op{}, l);
    auto p2 = p.add_instruction(pass_op{}, p1);
    auto p3 = p.add_instruction(pass_op{}, p2);
-    EXPECT(bool{migraph::instruction::get_output_alias(l) == l});
-    EXPECT(bool{migraph::instruction::get_output_alias(p1) == l});
-    EXPECT(bool{migraph::instruction::get_output_alias(p2) == l});
-    EXPECT(bool{migraph::instruction::get_output_alias(p3) == l});
+    EXPECT(bool{migraphx::instruction::get_output_alias(l) == l});
+    EXPECT(bool{migraphx::instruction::get_output_alias(p1) == l});
+    EXPECT(bool{migraphx::instruction::get_output_alias(p2) == l});
+    EXPECT(bool{migraphx::instruction::get_output_alias(p3) == l});
 }

 TEST_CASE(no_alias)
 {
-    migraph::program p;
+    migraphx::program p;
    auto x   = p.add_literal(1);
    auto y   = p.add_literal(2);
    auto sum = p.add_instruction(sum_op{}, x, y);
-    EXPECT(bool{migraph::instruction::get_output_alias(sum) == sum});
+    EXPECT(bool{migraphx::instruction::get_output_alias(sum) == sum});
 }

 int main(int argc, const char* argv[]) { test::run(argc, argv); }
--- a/test/program_test.cpp
+++ b/test/program_test.cpp

-#include <migraph/program.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/instruction.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/instruction.hpp>
 #include <sstream>
 #include "test.hpp"
 #include <basic_ops.hpp>

-migraph::program create_program()
+migraphx::program create_program()
 {
-    migraph::program p;
+    migraphx::program p;

-    auto x = p.add_parameter("x", {migraph::shape::int64_type});
-    auto y = p.add_parameter("y", {migraph::shape::int64_type});
+    auto x = p.add_parameter("x", {migraphx::shape::int64_type});
+    auto y = p.add_parameter("y", {migraphx::shape::int64_type});

    auto sum = p.add_instruction(sum_op{}, x, y);
    auto one = p.add_literal(1);
@@ -22,8 +22,8 @@ migraph::program create_program()

 TEST_CASE(program_equality)
 {
-    migraph::program x = create_program();
-    migraph::program y = create_program();
+    migraphx::program x = create_program();
+    migraphx::program y = create_program();
    EXPECT(x == y);
 }


--- a/test/shape_test.cpp
+++ b/test/shape_test.cpp

-#include <migraph/shape.hpp>
+#include <migraphx/shape.hpp>
 #include <array>
 #include <algorithm>
 #include <numeric>
@@ -7,22 +7,22 @@

 TEST_CASE(test_shape_default)
 {
-    migraph::shape s{};
+    migraphx::shape s{};
    EXPECT(s.elements() == 0);
    EXPECT(s.bytes() == 0);
 }

 TEST_CASE(test_shape_assign)
 {
-    migraph::shape s1{migraph::shape::float_type, {100, 32, 8, 8}};
-    migraph::shape s2 = s1; // NOLINT
+    migraphx::shape s1{migraphx::shape::float_type, {100, 32, 8, 8}};
+    migraphx::shape s2 = s1; // NOLINT
    EXPECT(s1 == s2);
    EXPECT(!(s1 != s2));
 }

 TEST_CASE(test_shape_packed_default)
 {
-    migraph::shape s{migraph::shape::float_type, {2, 2}};
+    migraphx::shape s{migraphx::shape::float_type, {2, 2}};
    EXPECT(s.standard());
    EXPECT(s.packed());
    EXPECT(not s.transposed());
@@ -31,7 +31,7 @@ TEST_CASE(test_shape_packed_default)

 TEST_CASE(test_shape_packed)
 {
-    migraph::shape s{migraph::shape::float_type, {2, 2}, {2, 1}};
+    migraphx::shape s{migraphx::shape::float_type, {2, 2}, {2, 1}};
    EXPECT(s.standard());
    EXPECT(s.packed());
    EXPECT(not s.transposed());
@@ -40,7 +40,7 @@ TEST_CASE(test_shape_packed)

 TEST_CASE(test_shape_transposed)
 {
-    migraph::shape s{migraph::shape::float_type, {2, 2}, {1, 2}};
+    migraphx::shape s{migraphx::shape::float_type, {2, 2}, {1, 2}};
    EXPECT(not s.standard());
    EXPECT(s.packed());
    EXPECT(s.transposed());
@@ -49,7 +49,7 @@ TEST_CASE(test_shape_transposed)

 TEST_CASE(test_shape_broadcasted)
 {
-    migraph::shape s{migraph::shape::float_type, {2, 2}, {1, 0}};
+    migraphx::shape s{migraphx::shape::float_type, {2, 2}, {1, 0}};
    EXPECT(not s.standard());
    EXPECT(not s.packed());
    EXPECT(not s.transposed());
@@ -58,20 +58,20 @@ TEST_CASE(test_shape_broadcasted)

 TEST_CASE(test_shape_default_copy)
 {
-    migraph::shape s1{};
-    migraph::shape s2{};
+    migraphx::shape s1{};
+    migraphx::shape s2{};
    EXPECT(s1 == s2);
    EXPECT(!(s1 != s2));
 }

 TEST_CASE(test_shape4)
 {
-    migraph::shape s{migraph::shape::float_type, {100, 32, 8, 8}};
+    migraphx::shape s{migraphx::shape::float_type, {100, 32, 8, 8}};
    EXPECT(s.standard());
    EXPECT(s.packed());
    EXPECT(not s.transposed());
    EXPECT(not s.broadcasted());
-    EXPECT(s.type() == migraph::shape::float_type);
+    EXPECT(s.type() == migraphx::shape::float_type);
    EXPECT(s.lens()[0] == 100);
    EXPECT(s.lens()[1] == 32);
    EXPECT(s.lens()[2] == 8);
@@ -99,12 +99,12 @@ TEST_CASE(test_shape4)

 TEST_CASE(test_shape42)
 {
-    migraph::shape s{migraph::shape::float_type, {100, 32, 8, 8}, {2048, 64, 8, 1}};
+    migraphx::shape s{migraphx::shape::float_type, {100, 32, 8, 8}, {2048, 64, 8, 1}};
    EXPECT(s.standard());
    EXPECT(s.packed());
    EXPECT(not s.transposed());
    EXPECT(not s.broadcasted());
-    EXPECT(s.type() == migraph::shape::float_type);
+    EXPECT(s.type() == migraphx::shape::float_type);
    EXPECT(s.lens()[0] == 100);
    EXPECT(s.lens()[1] == 32);
    EXPECT(s.lens()[2] == 8);
@@ -132,12 +132,12 @@ TEST_CASE(test_shape42)

 TEST_CASE(test_shape4_transposed)
 {
-    migraph::shape s{migraph::shape::float_type, {32, 100, 8, 8}, {64, 2048, 8, 1}};
+    migraphx::shape s{migraphx::shape::float_type, {32, 100, 8, 8}, {64, 2048, 8, 1}};
    EXPECT(s.transposed());
    EXPECT(s.packed());
    EXPECT(not s.standard());
    EXPECT(not s.broadcasted());
-    EXPECT(s.type() == migraph::shape::float_type);
+    EXPECT(s.type() == migraphx::shape::float_type);
    EXPECT(s.lens()[0] == 32);
    EXPECT(s.lens()[1] == 100);
    EXPECT(s.lens()[2] == 8);
@@ -179,12 +179,12 @@ TEST_CASE(test_shape4_nonpacked)
                     strides.rbegin() + 1,
                     std::multiplies<std::size_t>());

-    migraph::shape s{migraph::shape::float_type, lens, strides};
+    migraphx::shape s{migraphx::shape::float_type, lens, strides};
    EXPECT(not s.standard());
    EXPECT(not s.packed());
    EXPECT(not s.transposed());
    EXPECT(not s.broadcasted());
-    EXPECT(s.type() == migraph::shape::float_type);
+    EXPECT(s.type() == migraphx::shape::float_type);
    EXPECT(s.lens()[0] == 100);
    EXPECT(s.lens()[1] == 32);
    EXPECT(s.lens()[2] == 8);

--- a/test/simplify_algebra_test.cpp
+++ b/test/simplify_algebra_test.cpp
-#include <migraph/simplify_algebra.hpp>
-#include <migraph/dead_code_elimination.hpp>
-#include <migraph/operators.hpp>
+#include <migraphx/simplify_algebra.hpp>
+#include <migraphx/dead_code_elimination.hpp>
+#include <migraphx/operators.hpp>
 #include <basic_ops.hpp>
 #include <test.hpp>

 struct simplify_algebra_target
 {
    std::string name() const { return "simplify_algebra"; }
-    std::vector<migraph::pass> get_passes(migraph::context&) const
+    std::vector<migraphx::pass> get_passes(migraphx::context&) const
    {
-        return {migraph::simplify_algebra{}, migraph::dead_code_elimination{}};
+        return {migraphx::simplify_algebra{}, migraphx::dead_code_elimination{}};
    }
-    migraph::context get_context() const { return {}; }
+    migraphx::context get_context() const { return {}; }
 };

 TEST_CASE(simplify_add1)
 {
-    migraph::program p1;
+    migraphx::program p1;
    {
-        auto x    = p1.add_parameter("x", {migraph::shape::int32_type, {1}});
-        auto y    = p1.add_parameter("y", {migraph::shape::int32_type, {1}});
+        auto x    = p1.add_parameter("x", {migraphx::shape::int32_type, {1}});
+        auto y    = p1.add_parameter("y", {migraphx::shape::int32_type, {1}});
        auto one  = p1.add_literal(1);
        auto two  = p1.add_literal(2);
-        auto sum1 = p1.add_instruction(migraph::op::add{}, x, one);
-        auto sum2 = p1.add_instruction(migraph::op::add{}, y, two);
-        auto sum3 = p1.add_instruction(migraph::op::add{}, sum1, sum2);
+        auto sum1 = p1.add_instruction(migraphx::op::add{}, x, one);
+        auto sum2 = p1.add_instruction(migraphx::op::add{}, y, two);
+        auto sum3 = p1.add_instruction(migraphx::op::add{}, sum1, sum2);
        p1.add_instruction(pass_op{}, sum3);
    }
    p1.compile(simplify_algebra_target{});

-    migraph::program p2;
+    migraphx::program p2;
    {
-        auto x    = p2.add_parameter("x", {migraph::shape::int32_type, {1}});
-        auto y    = p2.add_parameter("y", {migraph::shape::int32_type, {1}});
+        auto x    = p2.add_parameter("x", {migraphx::shape::int32_type, {1}});
+        auto y    = p2.add_parameter("y", {migraphx::shape::int32_type, {1}});
        auto one  = p2.add_literal(1);
        auto two  = p2.add_literal(2);
-        auto sum1 = p2.add_instruction(migraph::op::add{}, one, two);
-        auto sum2 = p2.add_instruction(migraph::op::add{}, x, y);
-        auto sum3 = p2.add_instruction(migraph::op::add{}, sum2, sum1);
+        auto sum1 = p2.add_instruction(migraphx::op::add{}, one, two);
+        auto sum2 = p2.add_instruction(migraphx::op::add{}, x, y);
+        auto sum3 = p2.add_instruction(migraphx::op::add{}, sum2, sum1);
        p2.add_instruction(pass_op{}, sum3);
    }
    EXPECT(p1 == p2);
@@ -45,28 +45,28 @@ TEST_CASE(simplify_add1)

 TEST_CASE(simplify_add2)
 {
-    migraph::program p1;
+    migraphx::program p1;
    {
-        auto x    = p1.add_parameter("x", {migraph::shape::int32_type, {1}});
-        auto y    = p1.add_parameter("y", {migraph::shape::int32_type, {1}});
+        auto x    = p1.add_parameter("x", {migraphx::shape::int32_type, {1}});
+        auto y    = p1.add_parameter("y", {migraphx::shape::int32_type, {1}});
        auto one  = p1.add_literal(1);
        auto two  = p1.add_literal(2);
-        auto sum1 = p1.add_instruction(migraph::op::add{}, one, x);
-        auto sum2 = p1.add_instruction(migraph::op::add{}, two, y);
-        auto sum3 = p1.add_instruction(migraph::op::add{}, sum1, sum2);
+        auto sum1 = p1.add_instruction(migraphx::op::add{}, one, x);
+        auto sum2 = p1.add_instruction(migraphx::op::add{}, two, y);
+        auto sum3 = p1.add_instruction(migraphx::op::add{}, sum1, sum2);
        p1.add_instruction(pass_op{}, sum3);
    }
    p1.compile(simplify_algebra_target{});

-    migraph::program p2;
+    migraphx::program p2;
    {
-        auto x    = p2.add_parameter("x", {migraph::shape::int32_type, {1}});
-        auto y    = p2.add_parameter("y", {migraph::shape::int32_type, {1}});
+        auto x    = p2.add_parameter("x", {migraphx::shape::int32_type, {1}});
+        auto y    = p2.add_parameter("y", {migraphx::shape::int32_type, {1}});
        auto one  = p2.add_literal(1);
        auto two  = p2.add_literal(2);
-        auto sum1 = p2.add_instruction(migraph::op::add{}, one, two);
-        auto sum2 = p2.add_instruction(migraph::op::add{}, x, y);
-        auto sum3 = p2.add_instruction(migraph::op::add{}, sum2, sum1);
+        auto sum1 = p2.add_instruction(migraphx::op::add{}, one, two);
+        auto sum2 = p2.add_instruction(migraphx::op::add{}, x, y);
+        auto sum3 = p2.add_instruction(migraphx::op::add{}, sum2, sum1);
        p2.add_instruction(pass_op{}, sum3);
    }
    EXPECT(p1 == p2);
@@ -74,26 +74,26 @@ TEST_CASE(simplify_add2)

 TEST_CASE(simplify_add3)
 {
-    migraph::program p1;
+    migraphx::program p1;
    {
-        auto x    = p1.add_parameter("x", {migraph::shape::int32_type, {1}});
+        auto x    = p1.add_parameter("x", {migraphx::shape::int32_type, {1}});
        auto one  = p1.add_literal(1);
        auto two  = p1.add_literal(2);
-        auto sum1 = p1.add_instruction(migraph::op::add{}, one, x);
-        auto sum2 = p1.add_instruction(migraph::op::add{}, one, two);
-        auto sum3 = p1.add_instruction(migraph::op::add{}, sum1, sum2);
+        auto sum1 = p1.add_instruction(migraphx::op::add{}, one, x);
+        auto sum2 = p1.add_instruction(migraphx::op::add{}, one, two);
+        auto sum3 = p1.add_instruction(migraphx::op::add{}, sum1, sum2);
        p1.add_instruction(pass_op{}, sum3);
    }
    p1.compile(simplify_algebra_target{});

-    migraph::program p2;
+    migraphx::program p2;
    {
-        auto x    = p2.add_parameter("x", {migraph::shape::int32_type, {1}});
+        auto x    = p2.add_parameter("x", {migraphx::shape::int32_type, {1}});
        auto one  = p2.add_literal(1);
        auto two  = p2.add_literal(2);
-        auto sum1 = p2.add_instruction(migraph::op::add{}, one, x);
-        auto sum2 = p2.add_instruction(migraph::op::add{}, one, two);
-        auto sum3 = p2.add_instruction(migraph::op::add{}, sum1, sum2);
+        auto sum1 = p2.add_instruction(migraphx::op::add{}, one, x);
+        auto sum2 = p2.add_instruction(migraphx::op::add{}, one, two);
+        auto sum3 = p2.add_instruction(migraphx::op::add{}, sum1, sum2);
        p2.add_instruction(pass_op{}, sum3);
    }
    EXPECT(p1 == p2);
@@ -102,28 +102,28 @@ TEST_CASE(simplify_add3)
 // TODO: Add test case
 void simplify_add4()
 {
-    migraph::program p1;
+    migraphx::program p1;
    {
-        auto x    = p1.add_parameter("x", {migraph::shape::int32_type, {1}});
-        auto y    = p1.add_parameter("y", {migraph::shape::int32_type, {1}});
+        auto x    = p1.add_parameter("x", {migraphx::shape::int32_type, {1}});
+        auto y    = p1.add_parameter("y", {migraphx::shape::int32_type, {1}});
        auto one  = p1.add_literal(1);
        auto two  = p1.add_literal(2);
-        auto sum1 = p1.add_instruction(migraph::op::add{}, one, x);
-        auto sum2 = p1.add_instruction(migraph::op::add{}, sum1, y);
-        auto sum3 = p1.add_instruction(migraph::op::add{}, sum2, two);
+        auto sum1 = p1.add_instruction(migraphx::op::add{}, one, x);
+        auto sum2 = p1.add_instruction(migraphx::op::add{}, sum1, y);
+        auto sum3 = p1.add_instruction(migraphx::op::add{}, sum2, two);
        p1.add_instruction(pass_op{}, sum3);
    }
    p1.compile(simplify_algebra_target{});

-    migraph::program p2;
+    migraphx::program p2;
    {
-        auto x    = p2.add_parameter("x", {migraph::shape::int32_type, {1}});
-        auto y    = p2.add_parameter("y", {migraph::shape::int32_type, {1}});
+        auto x    = p2.add_parameter("x", {migraphx::shape::int32_type, {1}});
+        auto y    = p2.add_parameter("y", {migraphx::shape::int32_type, {1}});
        auto one  = p2.add_literal(1);
        auto two  = p2.add_literal(2);
-        auto sum1 = p2.add_instruction(migraph::op::add{}, one, two);
-        auto sum2 = p2.add_instruction(migraph::op::add{}, x, y);
-        auto sum3 = p2.add_instruction(migraph::op::add{}, sum2, sum1);
+        auto sum1 = p2.add_instruction(migraphx::op::add{}, one, two);
+        auto sum2 = p2.add_instruction(migraphx::op::add{}, x, y);
+        auto sum3 = p2.add_instruction(migraphx::op::add{}, sum2, sum1);
        p2.add_instruction(pass_op{}, sum3);
    }
    EXPECT(p1 == p2);

--- a/test/simplify_reshapes_test.cpp
+++ b/test/simplify_reshapes_test.cpp
-#include <migraph/simplify_reshapes.hpp>
-#include <migraph/dead_code_elimination.hpp>
-#include <migraph/operators.hpp>
+#include <migraphx/simplify_reshapes.hpp>
+#include <migraphx/dead_code_elimination.hpp>
+#include <migraphx/operators.hpp>
 #include <basic_ops.hpp>
 #include <test.hpp>

 struct simplify_reshapes_target
 {
    std::string name() const { return "simplify_reshapes"; }
-    std::vector<migraph::pass> get_passes(migraph::context&) const
+    std::vector<migraphx::pass> get_passes(migraphx::context&) const
    {
-        return {migraph::simplify_reshapes{}, migraph::dead_code_elimination{}};
+        return {migraphx::simplify_reshapes{}, migraphx::dead_code_elimination{}};
    }
-    migraph::context get_context() const { return {}; }
+    migraphx::context get_context() const { return {}; }
 };

 TEST_CASE(double_contig)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(get_2x2());
-    auto t1 = p.add_instruction(migraph::op::transpose{{1, 0}}, l);
-    auto c1 = p.add_instruction(migraph::op::contiguous{}, t1);
-    auto c2 = p.add_instruction(migraph::op::contiguous{}, c1);
+    auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
+    auto c1 = p.add_instruction(migraphx::op::contiguous{}, t1);
+    auto c2 = p.add_instruction(migraphx::op::contiguous{}, c1);
    p.add_instruction(pass_op{}, c2);
    EXPECT(p.get_shape().standard());
    EXPECT(not p.get_shape().transposed());
@@ -34,10 +34,10 @@ TEST_CASE(double_contig)

 TEST_CASE(double_transpose)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(get_2x2());
-    auto t1 = p.add_instruction(migraph::op::transpose{{1, 0}}, l);
-    auto t2 = p.add_instruction(migraph::op::transpose{{1, 0}}, t1);
+    auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
+    auto t2 = p.add_instruction(migraphx::op::transpose{{1, 0}}, t1);
    p.add_instruction(pass_op{}, t2);
    EXPECT(p.get_shape().standard());
    EXPECT(not p.get_shape().transposed());
@@ -51,12 +51,12 @@ TEST_CASE(double_transpose)

 TEST_CASE(double_transpose_contig)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(get_2x2());
-    auto t1 = p.add_instruction(migraph::op::transpose{{1, 0}}, l);
-    auto c1 = p.add_instruction(migraph::op::contiguous{}, t1);
-    auto t2 = p.add_instruction(migraph::op::transpose{{1, 0}}, c1);
-    auto c2 = p.add_instruction(migraph::op::contiguous{}, t2);
+    auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
+    auto c1 = p.add_instruction(migraphx::op::contiguous{}, t1);
+    auto t2 = p.add_instruction(migraphx::op::transpose{{1, 0}}, c1);
+    auto c2 = p.add_instruction(migraphx::op::contiguous{}, t2);
    p.add_instruction(pass_op{}, c2);
    EXPECT(p.get_shape().standard());
    EXPECT(not p.get_shape().transposed());
@@ -70,9 +70,9 @@ TEST_CASE(double_transpose_contig)

 TEST_CASE(single_transpose)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(get_2x2());
-    auto t1 = p.add_instruction(migraph::op::transpose{{1, 0}}, l);
+    auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
    p.add_instruction(pass_op{}, t1);
    EXPECT(not p.get_shape().standard());
    EXPECT(p.get_shape().transposed());
@@ -86,10 +86,10 @@ TEST_CASE(single_transpose)

 TEST_CASE(double_transpose_sin_pass)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l  = p.add_literal(get_2x2());
-    auto t1 = p.add_instruction(migraph::op::transpose{{1, 0}}, l);
-    p.add_instruction(migraph::op::transpose{{1, 0}}, t1);
+    auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
+    p.add_instruction(migraphx::op::transpose{{1, 0}}, t1);
    EXPECT(p.get_shape().standard());
    EXPECT(not p.get_shape().transposed());
    p.compile(simplify_reshapes_target{});
@@ -104,9 +104,9 @@ TEST_CASE(double_transpose_sin_pass)

 TEST_CASE(single_transpose_sin_pass)
 {
-    migraph::program p;
+    migraphx::program p;
    auto l = p.add_literal(get_2x2());
-    p.add_instruction(migraph::op::transpose{{1, 0}}, l);
+    p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
    EXPECT(not p.get_shape().standard());
    EXPECT(p.get_shape().transposed());
    p.compile(simplify_reshapes_target{});
@@ -117,4 +117,21 @@ TEST_CASE(single_transpose_sin_pass)
    EXPECT(result != get_2x2());
 }

+TEST_CASE(reshape_transpose)
+{
+    migraphx::program p;
+    auto s  = migraphx::shape{migraphx::shape::float_type, {1, 112, 56, 56}};
+    auto x  = p.add_parameter("x", s);
+    auto r1 = p.add_instruction(migraphx::op::reshape{{1, 4, 28, 56, 56}}, x);
+    auto t  = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3, 4}}, r1);
+    auto ct = p.add_instruction(migraphx::op::contiguous{}, t);
+    auto r2 = p.add_instruction(migraphx::op::reshape{{1, 112, 56, 56}}, ct);
+    p.add_instruction(pass_op{}, r2);
+    EXPECT(p.get_shape() == s);
+    auto n = std::distance(p.begin(), p.end());
+    p.compile(simplify_reshapes_target{});
+    EXPECT(p.get_shape() == s);
+    EXPECT(std::distance(p.begin(), p.end()) == n);
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }
--- a/test/type_name.cpp
+++ b/test/type_name.cpp

-#include <migraph/type_name.hpp>
+#include <migraphx/type_name.hpp>
 #include "test.hpp"

 struct global_class
@@ -21,8 +21,8 @@ struct ns_class

 int main()
 {
-    EXPECT(migraph::get_type_name<global_class>() == "global_class");
-    EXPECT(migraph::get_type_name<global_class::inner_class>() == "global_class::inner_class");
-    EXPECT(migraph::get_type_name<foo::ns_class>() == "foo::ns_class");
-    EXPECT(migraph::get_type_name<foo::ns_class::inner_class>() == "foo::ns_class::inner_class");
+    EXPECT(migraphx::get_type_name<global_class>() == "global_class");
+    EXPECT(migraphx::get_type_name<global_class::inner_class>() == "global_class::inner_class");
+    EXPECT(migraphx::get_type_name<foo::ns_class>() == "foo::ns_class");
+    EXPECT(migraphx::get_type_name<foo::ns_class::inner_class>() == "foo::ns_class::inner_class");
 }
--- a/test/validate.cpp
+++ b/test/validate.cpp
-#include <migraph/program.hpp>
-#include <migraph/instruction.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/instruction.hpp>
 #include <basic_ops.hpp>
 #include <test.hpp>
 #include <rob.hpp>

 TEST_CASE(simple_test)
 {
-    migraph::program p;
+    migraphx::program p;

    auto one = p.add_literal(1);
    auto two = p.add_literal(2);
    p.add_instruction(sum_op{}, one, two);
    EXPECT(bool{p.validate() == p.end()});
    auto result = p.eval({});
-    EXPECT(result == migraph::literal{3});
-    EXPECT(result != migraph::literal{4});
+    EXPECT(result == migraphx::literal{3});
+    EXPECT(result != migraphx::literal{4});
 }

 TEST_CASE(out_of_order)
 {
-    migraph::program p;
+    migraphx::program p;

    auto one = p.add_literal(1);
    auto two = p.add_literal(2);
@@ -30,7 +30,7 @@ TEST_CASE(out_of_order)

 TEST_CASE(incomplete_args)
 {
-    migraph::program p;
+    migraphx::program p;

    auto one = p.add_literal(1);
    auto two = p.add_literal(2);
@@ -39,14 +39,14 @@ TEST_CASE(incomplete_args)
    EXPECT(bool{p.validate() == ins});
 }

-MIGRAPH_ROB(access_ins_arguments,
-            std::vector<migraph::instruction_ref>,
-            migraph::instruction,
-            arguments)
+MIGRAPHX_ROB(access_ins_arguments,
+             std::vector<migraphx::instruction_ref>,
+             migraphx::instruction,
+             arguments)

 TEST_CASE(invalid_args)
 {
-    migraph::program p;
+    migraphx::program p;

    auto one = p.add_literal(1);
    auto two = p.add_literal(2);

--- a/tools/generate.sh
+++ b/tools/generate.sh
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-ls -1 $DIR/include/ | xargs -n 1 -P $(nproc) -I{} -t bash -c "python3.6 $DIR/te.py $DIR/include/{} | clang-format-5.0 -style=file > $DIR/../src/include/migraph/{}"
+ls -1 $DIR/include/ | xargs -n 1 -P $(nproc) -I{} -t bash -c "python3.6 $DIR/te.py $DIR/include/{} | clang-format-5.0 -style=file > $DIR/../src/include/migraphx/{}"
--- a/tools/include/concat_opt.hpp
+++ b/tools/include/concat_opt.hpp
-#ifndef MIGRAPH_GUARD_CONCAT_OPT_HPP
-#define MIGRAPH_GUARD_CONCAT_OPT_HPP
+#ifndef MIGRAPHX_GUARD_CONCAT_OPT_HPP
+#define MIGRAPHX_GUARD_CONCAT_OPT_HPP

 #include <cassert>
 #include <string>
@@ -8,10 +8,12 @@
 #include <type_traits>
 #include <utility>

-#include <migraph/operation.hpp>
-#include <migraph/operators.hpp>
+#include <migraphx/operation.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/config.hpp>

-namespace migraph {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {

 struct program;

@@ -40,6 +42,7 @@ interface('concat_optimization',

 #endif

-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

 #endif
--- a/tools/include/context.hpp
+++ b/tools/include/context.hpp
-#ifndef MIGRAPH_GUARD_CONTEXT_HPP
-#define MIGRAPH_GUARD_CONTEXT_HPP
+#ifndef MIGRAPHX_GUARD_CONTEXT_HPP
+#define MIGRAPHX_GUARD_CONTEXT_HPP

 #include <cassert>
 #include <string>
@@ -7,8 +7,10 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
+#include <migraphx/config.hpp>

-namespace migraph {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {

 #ifdef DOXYGEN

@@ -31,6 +33,7 @@ interface('context',

 #endif

-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

 #endif
--- a/tools/include/operation.hpp
+++ b/tools/include/operation.hpp
-#ifndef MIGRAPH_GUARD_MIGRAPHLIB_OPERAND_HPP
-#define MIGRAPH_GUARD_MIGRAPHLIB_OPERAND_HPP
+#ifndef MIGRAPHX_GUARD_MIGRAPHLIB_OPERAND_HPP
+#define MIGRAPHX_GUARD_MIGRAPHLIB_OPERAND_HPP

 #include <cassert>
 #include <string>
@@ -7,14 +7,16 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
-#include <migraph/shape.hpp>
-#include <migraph/reflect.hpp>
-#include <migraph/streamutils.hpp>
-#include <migraph/argument.hpp>
-#include <migraph/context.hpp>
-#include <migraph/auto_any_cast.hpp>
+#include <migraphx/shape.hpp>
+#include <migraphx/reflect.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/argument.hpp>
+#include <migraphx/context.hpp>
+#include <migraphx/auto_any_cast.hpp>
+#include <migraphx/config.hpp>

-namespace migraph {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {

 #ifdef DOXYGEN

@@ -24,6 +26,8 @@ struct operation
 {
    /// A unique name identifying the operation
    std::string name() const;
+    /// An optional method that can be used to finalize the operator before running
+    void finalize(context& ctx);
    /// This is used to compute the resulting shape from an operation. If an
    /// operation cannot be run with input shapes, then it should throw an
    /// exception.
@@ -51,6 +55,11 @@ struct operation
    friend std::ostream& operator<<(std::ostream& os, const operation& op);
 };

+/// Returns true if operation does not require a context to run compute
+bool is_context_free(const operation& x);
+/// Returns true if the operation has a finalize method
+bool has_finalize(const operation& x);
+
 #else

 namespace operation_stream {
@@ -87,7 +96,7 @@ auto operator==(const T& x, const U& y) -> decltype(x.name() == y.name())
 } // namespace operation_equal

 template <class T>
-auto compute_op(rank<1>,
+auto compute_op(rank<2>,
                const T& x,
                context& ctx,
                const shape& output_shape,
@@ -97,18 +106,72 @@ auto compute_op(rank<1>,
    return x.compute(auto_any_cast(ctx), output_shape, input);
 }

+template <class T>
+auto compute_op(
+    rank<1>, const T& x, context&, const shape& output_shape, const std::vector<argument>& input)
+    -> decltype(x.compute(output_shape, input))
+{
+    return x.compute(output_shape, input);
+}
+
 template <class T>
 argument compute_op(rank<0>, const T& x, context&, const shape&, const std::vector<argument>&)
 {
    std::string name = x.name();
-    MIGRAPH_THROW("Not computable: " + name);
+    MIGRAPHX_THROW("Not computable: " + name);
 }

 template <class T>
 argument
 compute_op(const T& x, context& ctx, const shape& output_shape, const std::vector<argument>& input)
 {
-    return compute_op(rank<1>{}, x, ctx, output_shape, input);
+    return compute_op(rank<2>{}, x, ctx, output_shape, input);
+}
+
+template <class T>
+auto compute_op(rank<2>, const T& x, const shape& output_shape, const std::vector<argument>& input)
+    -> decltype(x.compute(output_shape, input))
+{
+    return x.compute(output_shape, input);
+}
+
+template <class T>
+auto compute_op(rank<1>, const T& x, const shape& output_shape, const std::vector<argument>& input)
+    -> decltype(x.compute(auto_any_cast(std::declval<context&>()), output_shape, input))
+{
+    std::string name = x.name();
+    MIGRAPHX_THROW("Not computable without a context: " + name);
+}
+
+template <class T>
+argument compute_op(rank<0>, const T& x, const shape&, const std::vector<argument>&)
+{
+    std::string name = x.name();
+    MIGRAPHX_THROW("Not computable: " + name);
+}
+
+template <class T>
+argument compute_op(const T& x, const shape& output_shape, const std::vector<argument>& input)
+{
+    return compute_op(rank<2>{}, x, output_shape, input);
+}
+
+template <class T>
+auto is_context_free_op(rank<1>,
+                        const T& x,
+                        const shape& output_shape,
+                        const std::vector<argument>& input)
+    -> decltype(x.compute(output_shape, input), std::true_type{});
+
+template <class T>
+auto is_context_free_op(rank<0>, const T&, const shape&, const std::vector<argument>&)
+    -> std::false_type;
+
+template <class T>
+auto is_context_free_op(const T& x) -> decltype(is_context_free_op(
+    rank<1>{}, x, std::declval<const shape&>(), std::declval<std::vector<argument>>()))
+{
+    return {};
 }

 template <class T>
@@ -130,15 +193,60 @@ int output_alias_op(const T& x, const std::vector<shape>& shapes)
    return output_alias_op(rank<1>{}, x, shapes);
 }

+template <class T>
+auto finalize_op(
+    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
+    -> decltype(x.finalize(auto_any_cast(ctx), output_shape, input), void())
+{
+    x.finalize(auto_any_cast(ctx), output_shape, input);
+}
+
+template <class T>
+void finalize_op(rank<0>, T&, context&, const shape&, const std::vector<shape>&)
+{
+}
+
+template <class T>
+void finalize_op(T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
+{
+    finalize_op(rank<1>{}, x, ctx, output_shape, input);
+}
+
+template <class T>
+auto has_finalize_op(
+    rank<1>, T& x, context& ctx, const shape& output_shape, const std::vector<shape>& input)
+    -> decltype(x.finalize(auto_any_cast(ctx), output_shape, input), std::true_type{});
+
+template <class T>
+auto has_finalize_op(rank<0>, T&, context&, const shape&, const std::vector<shape>&)
+    -> std::false_type;
+
+template <class T>
+auto has_finalize_op(const T&) -> decltype(has_finalize_op(rank<1>{},
+                                                           std::declval<T&>(),
+                                                           std::declval<context&>(),
+                                                           std::declval<const shape&>(),
+                                                           std::declval<std::vector<shape>>()))
+{
+    return {};
+}
+
 <%
 interface(
     'operation',
     virtual('name', returns = 'std::string', const = True),
+     virtual('is_context_free', returns = 'bool', const = True, default = 'is_context_free_op'),
+     virtual('has_finalize', returns = 'bool', const = True, default = 'has_finalize_op'),
     virtual('output_alias',
             returns = 'int',
             input   = 'const std::vector<shape>&',
             const   = True,
             default = 'output_alias_op'),
+     virtual('finalize',
+             ctx     = 'context&',
+             output  = 'const shape&',
+             input   = 'const std::vector<shape>&',
+             default = 'finalize_op'),
     virtual('compute_shape', returns = 'shape', input = 'const std::vector<shape>&', const = True),
     virtual('compute',
             returns = 'argument',
@@ -147,24 +255,47 @@ int output_alias_op(const T& x, const std::vector<shape>& shapes)
             input   = 'const std::vector<argument>&',
             const   = True,
             default = 'compute_op'),
+     virtual('compute',
+             returns = 'argument',
+             output  = 'const shape&',
+             input   = 'const std::vector<argument>&',
+             const   = True,
+             default = 'compute_op'),
     friend('operator<<',
            returns = 'std::ostream &',
            os      = 'std::ostream &',
            op      = 'const operation &',
-            using   = 'migraph::operation_stream::operator<<'),
+            using   = 'migraphx::operation_stream::operator<<'),
     friend('operator==',
            returns = 'bool',
            x       = 'const operation &',
            y       = 'const operation &',
-            using   = 'migraph::operation_equal::operator==')) %>
+            using   = 'migraphx::operation_equal::operator==')) %>

    inline bool operator!=(const operation& x, const operation& y)
 {
    return !(x == y);
 }

+inline bool is_context_free(const operation& op) { return op.is_context_free(); }
+
+template <class T>
+bool is_context_free(const T& x)
+{
+    return is_context_free_op(x);
+}
+
+inline bool has_finalize(const operation& op) { return op.has_finalize(); }
+
+template <class T>
+bool has_finalize(const T& x)
+{
+    return has_finalize_op(x);
+}
+
 #endif

-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

 #endif