Change api to multiple prog outputs (only API change) (#433)

* Add initial api

* Formatting

* Add more api

* Formatting

* Add auto api generation

* Formatting

* Fix some compilation errors

* Change handle struct

* Formatting

* Fix reamining compilation errors

* Formatting

* Simplify using ctype

* Formatting

* Initial c++ generation

* Formatting

* Add C++header

* Formatting

* Add test

* Formatting

* Add initial tests

* Formatting

* Try to fix formatting

* Cleanup formatting

* Formatting

* Fix constructors on the same line

* Fix tests

* Formatting

* Fix tidy issues

* Fix tidy issues

* Fix naming issue

* Add onnx API to parse buffer

* Formatting

* Add arguments api

* Formatting

* Fix verify parameters

* Fix cppcheck issues

* Formatting

* Add method to get output shapes and bytes

* Formatting

* Try formatting

* Formatting

* Improve the test coverage

* Formatting

* Add print method

* Formatting

* Fix cppcheck issue

* Fix package dependency

* change migraphx api to support multiple program outputs

* clang format

* change api implementation

* clang format

* fix a build error

* change api for correct automatic generation

* clang format

* Add nolint

* Try fix formatting

* Formatting

* formatting

* formatting

* Fix formatting

* code cleanup

* clang format

* fix cppcheck error

* fix review comments

* clang format
Co-authored-by: Paul Fultz II <pfultz2@yahoo.com>
Co-authored-by: kahmed10 <15948690+kahmed10@users.noreply.github.com>

src/api/api.cpp

@@ -111,15 +111,10 @@ bool equal(const T& x, const T& y)
 
 std::vector<argument> run(program& p, const program::parameter_map& params)
 {
-    auto a = p.eval(params);
-    return {a};
+    return p.eval(params);
 }
 
-std::vector<shape> get_output_shapes(program& p)
-{
-    auto a = p.get_shape();
-    return {a};
-}
+std::vector<shape> get_output_shapes(program& p) { return p.get_output_shapes(); }
 
 void print(const program& p) { std::cout << p << std::endl; }
 

src/driver/verify.cpp

@@ -20,7 +20,7 @@ auto get_hash(const T& x)
     return std::hash<T>{}(x);
 }
 
-argument run_cpu(program p)
+std::vector<argument> run_cpu(program p)
 {
     p.compile(cpu::target{});
     program::parameter_map m;
@@ -33,7 +33,7 @@ argument run_cpu(program p)
     return out;
 }
 
-argument run_gpu(program p)
+std::vector<argument> run_gpu(program p)
 {
 #ifdef HAVE_GPU
     p.compile(gpu::target{});
@@ -43,9 +43,14 @@ argument run_gpu(program p)
     {
         m[x.first] = gpu::to_gpu(generate_argument(x.second, get_hash(x.first)));
     }
-    auto out = gpu::from_gpu(p.eval(m));
+    auto gpu_out = p.eval(m);
+    std::vector<argument> output(gpu_out.size());
     std::cout << p << std::endl;
-    return gpu::from_gpu(out);
+    std::transform(gpu_out.begin(), gpu_out.end(), output.begin(), [&](auto& argu) {
+        return gpu::from_gpu(argu);
+    });
+    return output;
+
 #else
     (void)p;
     MIGRAPHX_THROW("Gpu unsupported!");
@@ -56,7 +61,12 @@ void verify_program(const std::string& name, const program& p, double tolerance)
 {
     auto x = run_cpu(p);
     auto y = run_gpu(p);
-    verify_args(name, x, y, tolerance);
+
+    std::size_t output_num = x.size();
+    for(std::size_t i = 0; i < output_num; ++i)
+    {
+        verify_args(name, x[i], y[i], tolerance);
+    }
     // std::cout << "cpu: " << x << std::endl;
     // std::cout << "gpu: " << y << std::endl;
 }

src/driver/verify.hpp

@@ -7,8 +7,8 @@ namespace migraphx {
 namespace driver {
 inline namespace MIGRAPHX_INLINE_NS {
 
-argument run_cpu(program p);
-argument run_gpu(program p);
+std::vector<argument> run_cpu(program p);
+std::vector<argument> run_gpu(program p);
 void verify_program(const std::string& name, const program& p, double tolerance = 100);
 void verify_instructions(const program& prog, double tolerance = 80);
 void verify_reduced_program(const program& p, double tolerance = 80);

src/include/migraphx/program.hpp

@@ -93,7 +93,7 @@ struct program
 
     std::unordered_map<std::string, shape> get_parameter_shapes() const;
 
-    argument eval(parameter_map params) const;
+    std::vector<argument> eval(parameter_map params) const;
 
     bool has_instruction(instruction_ref ins) const;
 
@@ -101,7 +101,7 @@ struct program
     instruction_ref begin() const;
     instruction_ref end() const;
 
-    shape get_shape() const;
+    std::vector<shape> get_output_shapes() const;
 
     context& get_context() const;
 

src/onnx/cifar10.cpp

@@ -73,8 +73,9 @@ int main(int argc, char const* argv[])
         for(int i = 0; i < 10; i++)
         {
             std::cout << "label: " << static_cast<uint32_t>(labels[i]) << "  ---->  ";
-            m["0"]      = migraphx::gpu::to_gpu(migraphx::argument{s, &ptr[3072 * i]});
-            auto result = migraphx::gpu::from_gpu(prog.eval(m));
+            m["0"]          = migraphx::gpu::to_gpu(migraphx::argument{s, &ptr[3072 * i]});
+            auto gpu_result = prog.eval(m).back();
+            auto result     = migraphx::gpu::from_gpu(gpu_result);
             std::vector<float> logits;
             result.visit([&](auto output) { logits.assign(output.begin(), output.end()); });
             std::vector<float> probs = softmax<float>(logits);
@@ -95,7 +96,7 @@ int main(int argc, char const* argv[])
         {
             std::cout << "label: " << static_cast<uint32_t>(labels[i]) << "  ---->  ";
             auto input3 = migraphx::argument{s, &ptr[3072 * i]};
-            auto result = prog.eval({{"0", input3}});
+            auto result = prog.eval({{"0", input3}}).back();
             std::vector<float> logits;
             result.visit([&](auto output) { logits.assign(output.begin(), output.end()); });
             std::vector<float> probs = softmax<float>(logits);

src/onnx/mnist.cpp

@@ -130,8 +130,9 @@ int main(int argc, char const* argv[])
         for(int i = 0; i < 20; i++)
         {
             std::cout << "label: " << labels[i] << "  ---->  ";
-            m["0"]      = migraphx::gpu::to_gpu(migraphx::argument{s, &ptr[784 * i]});
-            auto result = migraphx::gpu::from_gpu(prog.eval(m));
+            m["0"]       = migraphx::gpu::to_gpu(migraphx::argument{s, &ptr[784 * i]});
+            auto results = prog.eval(m).back();
+            auto result  = migraphx::gpu::from_gpu(results);
             std::vector<float> logits;
             result.visit([&](auto output) { logits.assign(output.begin(), output.end()); });
             std::vector<float> probs = softmax(logits);

src/program.cpp

@@ -334,7 +334,10 @@ std::size_t program::size() const { return impl->instructions.size(); }
 instruction_ref program::begin() const { return impl->instructions.begin(); }
 instruction_ref program::end() const { return impl->instructions.end(); }
 
-shape program::get_shape() const { return impl->instructions.back().get_shape(); }
+std::vector<shape> program::get_output_shapes() const
+{
+    return {impl->instructions.back().get_shape()};
+}
 
 context& program::get_context() const { return impl->ctx; }
 
@@ -372,10 +375,10 @@ void program::finalize()
 }
 
 template <class F>
-argument generic_eval(const program& p,
-                      context& ctx,
-                      std::unordered_map<std::string, argument> params,
-                      F trace)
+std::vector<argument> generic_eval(const program& p,
+                                   context& ctx,
+                                   std::unordered_map<std::string, argument> params,
+                                   F trace)
 {
     assert(p.validate() == p.end());
     std::unordered_map<instruction_ref, argument> results;
@@ -421,10 +424,10 @@ argument generic_eval(const program& p,
         }
         assert(results.find(ins) != results.end());
     }
-    return results.at(std::prev(p.end()));
+    return {results.at(std::prev(p.end()))};
 }
 
-argument program::eval(std::unordered_map<std::string, argument> params) const
+std::vector<argument> program::eval(std::unordered_map<std::string, argument> params) const
 {
     auto& ctx = this->impl->ctx;
 #ifndef NDEBUG

src/py/migraphx_py.cpp

@@ -158,7 +158,7 @@ PYBIND11_MODULE(migraphx, m)
     py::class_<migraphx::program>(m, "program")
         .def("clone", [](migraphx::program& p) { return *(new migraphx::program(p)); })
         .def("get_parameter_shapes", &migraphx::program::get_parameter_shapes)
-        .def("get_shape", &migraphx::program::get_shape)
+        .def("get_output_shapes", &migraphx::program::get_output_shapes)
         .def("compile",
              [](migraphx::program& p, const migraphx::target& t, bool offload_copy) {
                  migraphx::compile_options options;

test/auto_contiguous_test.cpp

@@ -13,37 +13,37 @@ void literal_broadcast()
 {
     migraphx::program p;
     p.add_literal(get_2_broadcasted());
-    EXPECT(not p.get_shape().standard());
-    EXPECT(p.get_shape().broadcasted());
+    EXPECT(not p.get_output_shapes().back().standard());
+    EXPECT(p.get_output_shapes().back().broadcasted());
     run_pass(p);
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().broadcasted());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().broadcasted());
 }
 
 TEST_CASE(literal_transpose)
 {
     migraphx::program p;
     p.add_literal(get_2x2_transposed());
-    EXPECT(not p.get_shape().standard());
-    EXPECT(p.get_shape().transposed());
+    EXPECT(not p.get_output_shapes().back().standard());
+    EXPECT(p.get_output_shapes().back().transposed());
     run_pass(p);
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().transposed());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().transposed());
 }
 
 TEST_CASE(after_literal_transpose)
 {
     migraphx::program p;
     auto l = p.add_literal(get_2x2());
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().transposed());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().transposed());
     auto t = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
     p.add_instruction(pass_op{}, t);
-    EXPECT(not p.get_shape().standard());
-    EXPECT(p.get_shape().transposed());
+    EXPECT(not p.get_output_shapes().back().standard());
+    EXPECT(p.get_output_shapes().back().transposed());
     run_pass(p);
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().transposed());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().transposed());
 }
 
 TEST_CASE(after_literal_broadcast)
@@ -51,30 +51,30 @@ TEST_CASE(after_literal_broadcast)
     migraphx::program p;
     auto l1 = p.add_literal(get_2x2());
     auto l2 = p.add_literal(get_2());
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().broadcasted());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().broadcasted());
     auto b = p.add_instruction(migraphx::op::broadcast{0, l1->get_shape().lens()}, l2);
     p.add_instruction(pass_op{}, b);
-    EXPECT(not p.get_shape().standard());
-    EXPECT(p.get_shape().broadcasted());
+    EXPECT(not p.get_output_shapes().back().standard());
+    EXPECT(p.get_output_shapes().back().broadcasted());
     run_pass(p);
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().broadcasted());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().broadcasted());
 }
 
 TEST_CASE(after_param_transpose)
 {
     migraphx::program p;
     auto l = p.add_parameter("2x2", {migraphx::shape::float_type, {2, 2}});
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().transposed());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().transposed());
     auto t = p.add_instruction(migraphx::op::transpose{{1, 0}}, l);
     p.add_instruction(pass_op{}, t);
-    EXPECT(not p.get_shape().standard());
-    EXPECT(p.get_shape().transposed());
+    EXPECT(not p.get_output_shapes().back().standard());
+    EXPECT(p.get_output_shapes().back().transposed());
     run_pass(p);
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().transposed());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().transposed());
 }
 
 TEST_CASE(after_param_broadcast)
@@ -82,15 +82,15 @@ TEST_CASE(after_param_broadcast)
     migraphx::program p;
     auto l1 = p.add_parameter("2x2", {migraphx::shape::float_type, {2, 2}});
     auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {2}});
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().broadcasted());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().broadcasted());
     auto b = p.add_instruction(migraphx::op::broadcast{0, l1->get_shape().lens()}, l2);
     p.add_instruction(pass_op{}, b);
-    EXPECT(not p.get_shape().standard());
-    EXPECT(p.get_shape().broadcasted());
+    EXPECT(not p.get_output_shapes().back().standard());
+    EXPECT(p.get_output_shapes().back().broadcasted());
     run_pass(p);
-    EXPECT(p.get_shape().standard());
-    EXPECT(not p.get_shape().broadcasted());
+    EXPECT(p.get_output_shapes().back().standard());
+    EXPECT(not p.get_output_shapes().back().broadcasted());
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/cpu_dot_op_test.cpp

@@ -50,7 +50,7 @@ void matmul_test()
     auto bl = p.add_literal(migraphx::literal{b_shape, b});
     p.add_instruction(migraphx::op::dot{}, al, bl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<T> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(c, results_vector));
@@ -99,7 +99,7 @@ void matmul_test_ex()
     auto bl = p.add_literal(migraphx::literal{b_shape, b});
     p.add_instruction(migraphx::op::dot{}, al, bl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<T> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(c, results_vector));
@@ -134,7 +134,7 @@ TEST_CASE(matmul_mutli_dim_2)
 
     p.add_instruction(migraphx::op::dot{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
@@ -204,7 +204,7 @@ TEST_CASE(gemm_mutli_dim_2_beta0)
     float beta  = 0.0f;
     p.add_instruction(migraphx::op::dot{alpha, beta}, l1, l2, l3);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
@@ -265,7 +265,7 @@ TEST_CASE(gemm_beta_0)
     float beta  = 0.0f;
     p.add_instruction(migraphx::op::dot{alpha, beta}, l1, l2, l3);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
@@ -305,7 +305,7 @@ TEST_CASE(matmul_mutli_dim_2_3)
 
     p.add_instruction(migraphx::op::dot{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
@@ -355,7 +355,7 @@ TEST_CASE(gemm_mutli_dim1_2_3)
     auto m3_beta   = p.add_instruction(migraphx::op::mul{}, b_beta, l3);
     p.add_instruction(migraphx::op::add{}, m3_beta, m12_alpha);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
@@ -401,7 +401,7 @@ TEST_CASE(gemm_mutli_3args)
     float beta  = 0.41;
     p.add_instruction(migraphx::op::dot{alpha, beta}, l1, l2, l3);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
@@ -469,7 +469,7 @@ TEST_CASE(gemm_3args)
                                    5.74736,
                                    4.22063};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -505,7 +505,7 @@ TEST_CASE(matmul_vv_inner_product)
         p.add_instruction(migraphx::op::dot{}, ual, ubl);
         std::vector<float> gold = {-1.43461};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -539,7 +539,7 @@ TEST_CASE(matmul_vv_inner_product)
         p.add_instruction(migraphx::op::dot{alpha}, ual, ubl);
         std::vector<float> gold = {-0.4590752};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -575,7 +575,7 @@ TEST_CASE(matmul_vm)
         std::vector<float> gold = {-3.78111, -3.40007, -2.1972, -3.31448, -3.80326};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -609,7 +609,7 @@ TEST_CASE(matmul_vm)
         std::vector<float> gold = {-1.89056, -1.70003, -1.0986, -1.65724, -1.90163};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -653,7 +653,7 @@ TEST_CASE(matmul_vm)
                                    -2.45019,
                                    -1.35064};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -697,7 +697,7 @@ TEST_CASE(matmul_vm)
                                    -0.514539,
                                    -0.283635};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -734,7 +734,7 @@ TEST_CASE(matmul_mv)
         p.add_instruction(migraphx::op::dot{}, al, ubl);
         std::vector<float> gold = {1.31982, 1.19022, -1.96062};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -769,7 +769,7 @@ TEST_CASE(matmul_mv)
         p.add_instruction(migraphx::op::dot{alpha}, al, ubl);
         std::vector<float> gold = {0.395946, 0.357067, -0.588187};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -810,7 +810,7 @@ TEST_CASE(matmul_mv)
                                    3.29447,
                                    0.765651};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -861,7 +861,7 @@ TEST_CASE(matmul_mm1)
                                    0.77227,   0.349659,  2.92759,  2.32384,   -2.90664, 0.0527679,
                                    -0.547761, -0.155467, 0.964619, 2.09133,   -4.44281, -1.3864};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -911,7 +911,7 @@ TEST_CASE(matmul_mm1)
             -0.415107, 0.305138, 0.435993,  -0.107089, -0.767885,   -4.00837, 1.09921,   -2.02129,
             0.109717,  0.618422, 0.438342,  0.29602,   2.00928,     0.420871};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -953,7 +953,7 @@ TEST_CASE(matmul_mm2)
             0.60740202,  0.95217761,  -1.06087445, -4.75868152, -3.6687713,  -1.26539821};
         p.add_instruction(migraphx::op::dot{}, al, bbl);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -991,7 +991,7 @@ TEST_CASE(matmul_mm2)
             8.27398578e-01,  1.94406914e+00,  -2.39250915e-01, -1.77062701e+00, -6.46239534e-01,
             -7.95202750e-01};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1041,7 +1041,7 @@ TEST_CASE(matmul_mm2)
             0.63012062,  -0.25606052, -0.69419352, -1.78299913, -0.38572706, 1.92249442,
             0.3884186,   -0.48153048, 0.84932351,  0.67234919,  -1.07821322, -0.01208216};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1086,7 +1086,7 @@ TEST_CASE(matmul_mm2)
             1.92882983,  -0.30996324, 2.19736278,  2.32389426,  2.36741832,  1.62253915,
             0.26698225,  -0.00741609, -2.53680983, -0.0679954,  0.04499683,  0.85354276};
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1113,7 +1113,7 @@ TEST_CASE(quant_dot_2args_multi4)
                                  724, 762, 688, 742, 796, 850, 904, 958, 1012, 1066};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1138,7 +1138,7 @@ TEST_CASE(quant_dot_2args_multi4)
                                  736, 768, 592, 628, 664, 700, 736, 772, 808, 844};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1163,7 +1163,7 @@ TEST_CASE(quant_dot_2args_multi4)
                                  974, 1126, 86,  302, 518, 734, 950, 1166, 1382, 1598};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1189,7 +1189,7 @@ TEST_CASE(quant_dot_2args_multi4)
                                  836, 964, 74,  218, 362, 506, 650, 794, 938, 1082};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1215,7 +1215,7 @@ TEST_CASE(quant_dot_2args_general)
             70, 76, 82, 88, 94, 190, 212, 234, 256, 278, 310, 348, 386, 424, 462};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1239,7 +1239,7 @@ TEST_CASE(quant_dot_2args_general)
             210, 228, 246, 264, 282, 240, 262, 284, 306, 328, 270, 296, 322, 348, 374};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1268,7 +1268,7 @@ TEST_CASE(quant_dot_2args_general)
             28, 76, 124, 172, 220, 76, 252, 428, 604, 780, 124, 428, 732, 1036, 1340};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1293,7 +1293,7 @@ TEST_CASE(quant_dot_2args_general)
             126, 342, 558, 774, 990, 144, 408, 672, 936, 1200, 162, 474, 786, 1098, 1410};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1323,7 +1323,7 @@ TEST_CASE(quant_dot_3args_general)
             982, 1011, 1040, 1069, 1098, 1127, 1156, 2557, 2650, 2743, 2836, 2929, 3022, 3115};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1350,7 +1350,7 @@ TEST_CASE(quant_dot_3args_general)
             70, 76, 82, 88, 94, 190, 212, 234, 256, 278, 310, 348, 386, 424, 462};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1378,7 +1378,7 @@ TEST_CASE(quant_dot_3args_general)
             1966, 2025, 2084, 2143, 2202, 2261, 2320, 2183, 2250, 2317, 2384, 2451, 2518, 2585};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1406,7 +1406,7 @@ TEST_CASE(quant_dot_3args_general)
             286, 737, 1188, 1639, 2090, 2541, 2992, 755, 2230, 3705, 5180, 6655, 8130, 9605};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1435,7 +1435,7 @@ TEST_CASE(quant_dot_3args_general)
             844, 2190, 3536, 4882, 6228, 7574, 8920, 942, 2480, 4018, 5556, 7094, 8632, 10170};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1469,7 +1469,7 @@ TEST_CASE(quant_dot_3args_batch)
             10386, 11288, 11408, 11528, 11648, 11768, 11888, 12008};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));
@@ -1503,7 +1503,7 @@ TEST_CASE(quant_dot_3args_batch)
             24618, 25949, 27280, 28611, 29942, 31273, 25224, 26587, 27950, 29313, 30676, 32039};
 
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> m;
         result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(m, gold));

test/dead_code_elimination_test.cpp

@@ -21,7 +21,7 @@ TEST_CASE(simple_test)
     auto count = std::distance(p.begin(), p.end());
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == count);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -37,7 +37,7 @@ TEST_CASE(simple_test_nop)
     auto count = std::distance(p.begin(), p.end());
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == count);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -53,7 +53,7 @@ TEST_CASE(simple_test_nop2)
     p.add_instruction(nop{});
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == 2);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{});
     EXPECT(result != migraphx::literal{4});
 }
@@ -69,7 +69,7 @@ TEST_CASE(duplicate_test1)
     auto count = std::distance(p.begin(), p.end());
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == (count - 1));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -86,7 +86,7 @@ TEST_CASE(duplicate_test2)
     auto count = std::distance(p.begin(), p.end());
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == (count - 2));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -105,7 +105,7 @@ TEST_CASE(depth_test)
     auto count = std::distance(p.begin(), p.end());
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == (count - 4));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -122,7 +122,7 @@ TEST_CASE(undefined_test)
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) == count - 1);
     EXPECT(not p.has_instruction(undef));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -139,7 +139,7 @@ TEST_CASE(duplicate_args1)
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) != count);
     EXPECT(std::distance(p.begin(), p.end()) == 2);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{0});
 }
 
@@ -156,7 +156,7 @@ TEST_CASE(duplicate_args2)
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) != count);
     EXPECT(std::distance(p.begin(), p.end()) == 2);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{0});
 }
 
@@ -174,7 +174,7 @@ TEST_CASE(duplicate_args3)
     run_pass(p);
     EXPECT(std::distance(p.begin(), p.end()) != count);
     EXPECT(std::distance(p.begin(), p.end()) == 2);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{0});
 }
 

test/eliminate_allocation_test.cpp

@@ -49,7 +49,7 @@ TEST_CASE(basic)
     p.add_instruction(pass_op{}, a3, p2);
 
     run_pass(p);
-    EXPECT(p.get_shape() == migraphx::shape{migraphx::shape::float_type, {200}});
+    EXPECT(p.get_output_shapes().back() == migraphx::shape{migraphx::shape::float_type, {200}});
     EXPECT(p.get_parameter_shape("memory").bytes() == (8 * 4 + 40 * 4 + 200 * 4));
 }
 
@@ -66,7 +66,7 @@ TEST_CASE(aligned)
     p.add_instruction(pass_op{}, a3, p2);
 
     run_pass(p);
-    EXPECT(p.get_shape() == migraphx::shape{migraphx::shape::float_type, {200}});
+    EXPECT(p.get_output_shapes().back() == migraphx::shape{migraphx::shape::float_type, {200}});
     EXPECT(p.get_parameter_shape("memory").bytes() == (32 + 32 + 200 * 4));
 }
 
@@ -83,7 +83,7 @@ TEST_CASE(unaligned)
     p.add_instruction(pass_op{}, a3, p2);
 
     run_pass(p, 1);
-    EXPECT(p.get_shape() == migraphx::shape{migraphx::shape::float_type, {200}});
+    EXPECT(p.get_output_shapes().back() == migraphx::shape{migraphx::shape::float_type, {200}});
     EXPECT(p.get_parameter_shape("memory").bytes() == (1 * 4 + 2 * 4 + 200 * 4));
 }
 
@@ -100,7 +100,7 @@ TEST_CASE(float_aligned)
     p.add_instruction(pass_op{}, a3, p2);
 
     run_pass(p, 4);
-    EXPECT(p.get_shape() == migraphx::shape{migraphx::shape::float_type, {200}});
+    EXPECT(p.get_output_shapes().back() == migraphx::shape{migraphx::shape::float_type, {200}});
     EXPECT(p.get_parameter_shape("memory").bytes() == (1 * 4 + 2 * 4 + 200 * 4));
 }
 

test/eliminate_identity_test.cpp

@@ -21,7 +21,7 @@ TEST_CASE(simple_test)
     EXPECT(std::none_of(p.begin(), p.end(), [](const migraphx::instruction& ins) {
         return ins.name() == "identity";
     }));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
 }
 
@@ -37,7 +37,7 @@ TEST_CASE(simple_test_end)
     EXPECT(std::none_of(p.begin(), p.end(), [](const migraphx::instruction& ins) {
         return ins.name() == "identity";
     }));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
 }
 
@@ -55,7 +55,7 @@ TEST_CASE(simple_test_end_dependency)
     EXPECT(std::any_of(p.begin(), p.end(), [](const migraphx::instruction& ins) {
         return ins.name() == "identity";
     }));
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3.0});
 }
 

test/eval_test.cpp

@@ -134,7 +134,7 @@ TEST_CASE(literal_test1)
     auto one = p.add_literal(1);
     auto two = p.add_literal(2);
     p.add_instruction(sum_op{}, one, two);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -148,7 +148,7 @@ TEST_CASE(literal_test2)
     auto sum1 = p.add_instruction(sum_op{}, one, two);
     p.add_instruction(sum_op{}, sum1, two);
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{5});
     EXPECT(result != migraphx::literal{3});
 }
@@ -175,8 +175,9 @@ TEST_CASE(param_test)
     auto y = p.add_parameter("y", {migraphx::shape::int32_type});
 
     p.add_instruction(sum_op{}, x, y);
-    auto result = p.eval(
-        {{"x", migraphx::literal{1}.get_argument()}, {"y", migraphx::literal{2}.get_argument()}});
+    auto result = p.eval({{"x", migraphx::literal{1}.get_argument()},
+                          {"y", migraphx::literal{2}.get_argument()}})
+                      .back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -258,7 +259,7 @@ TEST_CASE(replace_test)
     p.replace_instruction(sum, minus_op{}, two, one);
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{1});
     EXPECT(result != migraphx::literal{3});
 }
@@ -274,7 +275,7 @@ TEST_CASE(replace_ins_test)
     p.replace_instruction(sum, minus);
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{1});
     EXPECT(result != migraphx::literal{3});
 }
@@ -291,7 +292,7 @@ TEST_CASE(replace_ins_test2)
     p.replace_instruction(two, sum);
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{2});
     EXPECT(result != migraphx::literal{3});
 }
@@ -306,7 +307,7 @@ TEST_CASE(replace_op_test)
     sum->replace(minus_op{});
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{1});
     EXPECT(result != migraphx::literal{3});
 }
@@ -334,7 +335,7 @@ TEST_CASE(insert_replace_test)
     p.replace_instruction(sum1, minus_op{}, sum0, two);
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{4});
     EXPECT(result != migraphx::literal{5});
 }
@@ -350,7 +351,7 @@ TEST_CASE(remove_test1)
     p.remove_instruction(removed);
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{1});
 }
@@ -366,7 +367,7 @@ TEST_CASE(remove_test2)
     p.remove_instruction(removed);
     EXPECT(bool{p.validate() == p.end()});
 
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{1});
 }
@@ -379,7 +380,7 @@ TEST_CASE(target_test)
     auto two = p.add_literal(2);
     p.add_instruction(sum_op{}, one, two);
     p.compile(id_target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -392,7 +393,7 @@ TEST_CASE(invert_target_test)
     auto two = p.add_literal(2);
     p.add_instruction(sum_op{}, two, one);
     p.compile(invert_target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{1});
     EXPECT(result != migraphx::literal{4});
 }
@@ -405,7 +406,7 @@ TEST_CASE(double_invert_target_test)
     auto two = p.add_literal(2);
     p.add_instruction(sum_op{}, two, one);
     p.compile(double_invert_target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});
 }
@@ -432,7 +433,7 @@ TEST_CASE(eval_context1)
     p.add_instruction(sum_op{}, one, two);
     p.compile(t);
     EXPECT(is_shared(t.ctx, p.get_context()));
-    p.eval({});
+    p.eval({}).back();
     EXPECT(is_shared(t.ctx, p.get_context()));
 }
 
@@ -446,7 +447,7 @@ TEST_CASE(eval_context2)
     p.add_instruction(id_ctx_op{}, one, two);
     p.compile(t);
     EXPECT(is_shared(t.ctx, p.get_context()));
-    p.eval({});
+    p.eval({}).back();
     // id_ctx_op will modify the context
     EXPECT(not is_shared(t.ctx, p.get_context()));
 }
@@ -463,7 +464,7 @@ TEST_CASE(eval_context3)
     // Finalizer will modify the context
     EXPECT(not is_shared(t.ctx, p.get_context()));
     auto ctx = p.get_context();
-    p.eval({});
+    p.eval({}).back();
     EXPECT(is_shared(ctx, p.get_context()));
     EXPECT(not is_shared(t.ctx, p.get_context()));
 }

test/gpu/literal.cpp

@@ -15,7 +15,7 @@ void gpu_literal_test()
     auto scratch = p.get_parameter("scratch");
     if(scratch == p.end())
     {
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(lit == migraphx::gpu::from_gpu(result));
     }
     else

test/gpu/ops_test.cpp

@@ -88,12 +88,12 @@ auto get_hash(const T& x)
 void compile_check(migraphx::program& p, const migraphx::target& t, bool show_trace = false)
 {
     auto name = t.name();
-    auto s    = p.get_shape();
+    auto s    = p.get_output_shapes().back();
     std::stringstream ss;
     migraphx::compile_options options;
     options.trace = migraphx::tracer{ss};
     p.compile(t, options);
-    if(p.get_shape() != s)
+    if(p.get_output_shapes().back() != s)
     {
         std::cout << ss.str() << std::endl;
         throw std::runtime_error("Compiling program with " + name + " alters its shape");
@@ -105,7 +105,7 @@ void compile_check(migraphx::program& p, const migraphx::target& t, bool show_tr
 }
 
 template <class V>
-migraphx::argument run_cpu(migraphx::program& p)
+std::vector<migraphx::argument> run_cpu(migraphx::program& p)
 {
     V v;
     p = v.create_program();
@@ -120,7 +120,7 @@ migraphx::argument run_cpu(migraphx::program& p)
 }
 
 template <class V>
-migraphx::argument run_gpu(migraphx::program& p)
+std::vector<migraphx::argument> run_gpu(migraphx::program& p)
 {
     V v;
     p = v.create_program();
@@ -141,7 +141,14 @@ migraphx::argument run_gpu(migraphx::program& p)
     p.dry_run(m);
     EXPECT(is_shared(ctx, p.get_context()));
     p.eval(m);
-    return migraphx::gpu::from_gpu(p.eval(m));
+
+    auto gpu_res = p.eval(m);
+    std::vector<migraphx::argument> res(gpu_res.size());
+    std::transform(gpu_res.begin(), gpu_res.end(), res.begin(), [&](auto& argu) {
+        return migraphx::gpu::from_gpu(argu);
+    });
+
+    return res;
 }
 
 template <class V>
@@ -154,7 +161,15 @@ void run_verify_program()
     auto cpu_arg_f = detach_async([&] { return run_cpu<V>(cpu_prog); });
     auto gpu_arg   = run_gpu<V>(gpu_prog);
     auto cpu_arg   = cpu_arg_f.get();
-    bool passed    = verify_args(migraphx::get_type_name<V>(), cpu_arg, gpu_arg);
+
+    bool passed = true;
+    passed &= (cpu_arg.size() == gpu_arg.size());
+    std::size_t num = cpu_arg.size();
+    for(std::size_t i = 0; ((i < num) and passed); ++i)
+    {
+        passed &= verify_args(migraphx::get_type_name<V>(), cpu_arg[i], gpu_arg[i]);
+    }
+
     if(not passed)
     {
         V v;
@@ -1759,7 +1774,7 @@ struct test_contiguous : verify_program<test_contiguous>
         migraphx::shape s{migraphx::shape::float_type, {4, 4, 4, 3}, {48, 4, 1, 16}};
         auto x = p.add_parameter("x", s);
         p.add_instruction(migraphx::op::contiguous{}, x);
-        EXPECT(p.get_shape().standard());
+        EXPECT(p.get_output_shapes().back().standard());
         return p;
     }
 };
@@ -1772,7 +1787,7 @@ struct test_contiguous_broadcast : verify_program<test_contiguous_broadcast>
         migraphx::shape s{migraphx::shape::float_type, {1, 2}, {0, 1}};
         auto x = p.add_parameter("x", s);
         p.add_instruction(migraphx::op::contiguous{}, x);
-        EXPECT(p.get_shape().standard());
+        EXPECT(p.get_output_shapes().back().standard());
         return p;
     }
 };
@@ -1785,7 +1800,7 @@ struct test_contiguous_broadcast_transpose : verify_program<test_contiguous_broa
         migraphx::shape s{migraphx::shape::float_type, {1, 3072, 768}, {0, 1, 3072}};
         auto x = p.add_parameter("x", s);
         p.add_instruction(migraphx::op::contiguous{}, x);
-        EXPECT(p.get_shape().standard());
+        EXPECT(p.get_output_shapes().back().standard());
         return p;
     }
 };
@@ -2270,7 +2285,7 @@ void manual_identity()
     {
         m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
     }
-    auto result = migraphx::gpu::from_gpu(p.eval(m));
+    auto result = migraphx::gpu::from_gpu(p.eval(m).back());
     std::cout << result << std::endl;
 }
 
@@ -2299,7 +2314,7 @@ void manual_test_concat_relu()
     {
         m[x.first] = migraphx::gpu::to_gpu(migraphx::generate_argument(x.second));
     }
-    auto result = migraphx::gpu::from_gpu(p.eval(m));
+    auto result = migraphx::gpu::from_gpu(p.eval(m).back());
     std::cout << result << std::endl;
 }
 

test/gpu/quantization.cpp

@@ -56,7 +56,7 @@ TEST_CASE(int8_quantization)
             }
         }
 
-        auto result = t.copy_from(p.eval(m));
+        auto result = t.copy_from(p.eval(m).back());
         result.visit([&](auto v) { res.assign(v.begin(), v.end()); });
     };
 

test/memory_coloring_test.cpp

@@ -606,7 +606,7 @@ TEST_CASE(literal_test)
     auto lit = generate_literal(migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
     p.add_literal(lit);
     run_pass(p);
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     CHECK(lit == result);
 }