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/cpu_ops_test.cpp

@@ -25,10 +25,10 @@ TEST_CASE(slice_test)
         auto l0 = p.add_literal(migraphx::literal{s, data});
         p.add_instruction(migraphx::op::slice{{2}, {1}, {3}}, l0);
         migraphx::shape s2{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
-        EXPECT(p.get_shape() == s2);
+        EXPECT(p.get_output_shapes().back() == s2);
         p.compile(migraphx::cpu::target{});
         migraphx::shape sresult{migraphx::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
-        auto result           = p.eval({});
+        auto result           = p.eval({}).back();
         std::vector<int> gold = {1, 2, 4, 5, 7, 8, 10, 11};
         std::vector<int> results_vector(2 * 2 * 2);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -43,10 +43,10 @@ TEST_CASE(slice_test)
         auto l0 = p.add_literal(migraphx::literal{s, data});
         p.add_instruction(migraphx::op::slice{{0, 1, 2}, {0, 0, 0}, {2, 2, 2}}, l0);
         migraphx::shape s2{migraphx::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
-        EXPECT(p.get_shape() == s2);
+        EXPECT(p.get_output_shapes().back() == s2);
         p.compile(migraphx::cpu::target{});
         migraphx::shape sresult{migraphx::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
-        auto result           = p.eval({});
+        auto result           = p.eval({}).back();
         std::vector<int> gold = {0, 1, 3, 4, 6, 7, 9, 10};
         std::vector<int> results_vector(2 * 2 * 2);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -71,7 +71,7 @@ TEST_CASE(concat_test)
         auto l2 = p.add_literal(migraphx::literal{s2, data2});
         p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
         p.compile(migraphx::cpu::target{});
-        auto result           = p.eval({});
+        auto result           = p.eval({}).back();
         std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
         std::vector<int> results_vector(2 * 6);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -95,7 +95,7 @@ TEST_CASE(concat_test)
         auto l2 = p.add_literal(migraphx::literal{s2, data2});
         p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
         p.compile(migraphx::cpu::target{});
-        auto result           = p.eval({});
+        auto result           = p.eval({}).back();
         std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
         std::vector<int> results_vector(2 * 6);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -119,7 +119,7 @@ TEST_CASE(concat_test)
         auto l2 = p.add_literal(migraphx::literal{s2, data2});
         p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
         p.compile(migraphx::cpu::target{});
-        auto result           = p.eval({});
+        auto result           = p.eval({}).back();
         std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
         std::vector<int> results_vector(6 * 2);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -143,7 +143,7 @@ TEST_CASE(concat_test)
         auto l2 = p.add_literal(migraphx::literal{s2, data2});
         p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
         p.compile(migraphx::cpu::target{});
-        auto result           = p.eval({});
+        auto result           = p.eval({}).back();
         std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
         std::vector<int> results_vector(6 * 2);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -169,7 +169,7 @@ TEST_CASE(gather_test)
         int axis = 0;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data(4 * 5);
         std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -189,7 +189,7 @@ TEST_CASE(gather_test)
         int axis = 0;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data(4 * 5);
         std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -209,7 +209,7 @@ TEST_CASE(gather_test)
         int axis = 1;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data(4 * 5);
         std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -229,7 +229,7 @@ TEST_CASE(gather_test)
         int axis = -1;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data(4 * 5);
         std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -250,7 +250,7 @@ TEST_CASE(gather_test)
         int axis = -1;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data{};
         std::vector<float> golden = {0.5f, 3.5f, 6.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -271,7 +271,7 @@ TEST_CASE(gather_test)
         int axis = -1;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data{};
         std::vector<float> golden = {0.5f, 3.5f, 6.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -292,7 +292,7 @@ TEST_CASE(gather_test)
         int axis = -1;
         p.add_instruction(migraphx::op::gather{axis}, a0, a1);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res_data{};
         std::vector<float> golden = {0.5f};
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
@@ -310,7 +310,7 @@ TEST_CASE(squeeze_test)
         auto l0 = p.add_literal(migraphx::literal{s1, data});
         p.add_instruction(migraphx::op::squeeze{{1}}, l0);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape() == s2);
     }
     {
@@ -321,7 +321,7 @@ TEST_CASE(squeeze_test)
         auto l0 = p.add_literal(migraphx::literal{s1, data});
         p.add_instruction(migraphx::op::squeeze{{3}}, l0);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape() == s2);
     }
 
@@ -333,7 +333,7 @@ TEST_CASE(squeeze_test)
         auto l0 = p.add_literal(migraphx::literal{s1, data});
         p.add_instruction(migraphx::op::squeeze{}, l0);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape() == s2);
     }
 }
@@ -348,7 +348,7 @@ TEST_CASE(unsqueeze_test)
         auto l0 = p.add_literal(migraphx::literal{s1, data});
         p.add_instruction(migraphx::op::unsqueeze{{1}}, l0);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape() == s2);
     }
     {
@@ -359,7 +359,7 @@ TEST_CASE(unsqueeze_test)
         auto l0 = p.add_literal(migraphx::literal{s1, data});
         p.add_instruction(migraphx::op::unsqueeze{{2}}, l0);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape() == s2);
     }
 }
@@ -376,7 +376,7 @@ TEST_CASE(globalavgpool_test)
     auto l0 = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(op, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -396,7 +396,7 @@ TEST_CASE(globalmaxpool_test)
     auto l0 = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(op, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -424,7 +424,7 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
     auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
     p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
@@ -453,7 +453,7 @@ TEST_CASE(im2col_3x3_no_pad_test)
     auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
     p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<int> correct = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
                                 4, 5, 6, 8, 9, 10, 12, 13, 14, 5, 6, 7, 9, 10, 11, 13, 14, 15};
@@ -485,7 +485,7 @@ TEST_CASE(im2col_3x3_stride_2_no_pad_test)
     auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
     p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<int> correct = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
                                 8,  9,  10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
@@ -518,7 +518,7 @@ TEST_CASE(im2col_3x3_with_padding_test)
     auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
     p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<int> correct = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
                                 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
@@ -566,7 +566,7 @@ TEST_CASE(batch_norm_inference_test)
 
     p.add_instruction(migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> result_vector(width * height * channels * batches);
     std::vector<float> gold(width * height * channels * batches);
@@ -596,7 +596,7 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
     auto l_weights = p.add_literal(migraphx::literal{s_weights, weights});
     p.add_instruction(migraphx::op::im2col{padding, stride, dilation}, l_image, l_weights);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
@@ -612,7 +612,7 @@ TEST_CASE(exp_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
     p.add_instruction(migraphx::op::exp{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.36787944f, 1.f, 2.71828183f};
@@ -627,7 +627,7 @@ TEST_CASE(erf_test)
         p.add_literal(migraphx::literal{s, {0.73785057, 1.58165966, -0.43597795, -0.01677432}});
     p.add_instruction(migraphx::op::erf{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.70327317, 0.97470088, -0.46247893, -0.01892602};
@@ -642,7 +642,7 @@ TEST_CASE(sqrt_test)
         migraphx::literal{s, {1.02481645, 0.85643062, 0.03404123, 0.92791926, 0.10569184}});
     p.add_instruction(migraphx::op::sqrt{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {1.01233218, 0.92543537, 0.18450265, 0.96328566, 0.32510282};
@@ -657,7 +657,7 @@ TEST_CASE(sign_test)
         migraphx::literal{s, {1.02481645, 0.85643062, -0.03404123, -0.92791926, 0.0}});
     p.add_instruction(migraphx::op::sign{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {1.0, 1.0, -1.0, -1.0, 0.0};
@@ -671,7 +671,7 @@ TEST_CASE(log_test)
     auto l = p.add_literal(migraphx::literal{s, {1, 2, 3}});
     p.add_instruction(migraphx::op::log{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.0f, 0.6931471806f, 1.0986122887f};
@@ -686,7 +686,7 @@ TEST_CASE(pow_test)
     auto e = p.add_literal(migraphx::literal{s, {1, 2, 3}});
     p.add_instruction(migraphx::op::pow{}, b, e);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {1.0f, 4.0f, 27.0f};
@@ -700,7 +700,7 @@ TEST_CASE(sin_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
     p.add_instruction(migraphx::op::sin{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.84147098f, 0.f, 0.84147098f};
@@ -714,7 +714,7 @@ TEST_CASE(cos_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
     p.add_instruction(migraphx::op::cos{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.54030231f, 1.f, 0.54030231f};
@@ -728,7 +728,7 @@ TEST_CASE(tan_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
     p.add_instruction(migraphx::op::tan{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-1.55740772f, 0.0f, 1.55740772f};
@@ -743,7 +743,7 @@ TEST_CASE(asin_test)
     auto l = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(migraphx::op::asin{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.5235987756f, 0.f, 1.119769515};
@@ -758,7 +758,7 @@ TEST_CASE(acos_test)
     auto l = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(migraphx::op::acos{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {2.4980915448f, 1.5707963268f, 0.0f};
@@ -772,7 +772,7 @@ TEST_CASE(atan_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 0, 1}});
     p.add_instruction(migraphx::op::atan{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.7853981634f, 0.0f, 0.7853981634f};
@@ -787,7 +787,7 @@ TEST_CASE(asinh_test)
     auto l = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(migraphx::op::asinh{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.481211841, 0, 0.808866858};
@@ -802,7 +802,7 @@ TEST_CASE(acosh_test)
     auto l = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(migraphx::op::acosh{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.4435683, 0.6223626, 1.316958};
@@ -816,7 +816,7 @@ TEST_CASE(atanh_test)
     auto l = p.add_literal(migraphx::literal{s, {0.4435683, 0.6223626, 0.316958}});
     p.add_instruction(migraphx::op::atanh{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.476664424, 0.728852153, 0.328261733};
@@ -831,7 +831,7 @@ TEST_CASE(add_test)
     auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
     p.add_instruction(migraphx::op::add{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 2, 4};
@@ -850,7 +850,7 @@ TEST_CASE(broadcast_test)
     auto l2       = p.add_literal(migraphx::literal{b_shape, b_data});
     p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     auto output = result.get<int32_t>();
     EXPECT(output(0, 0) == -2);
     EXPECT(output(0, 1) == -2);
@@ -871,7 +871,7 @@ TEST_CASE(add_broadcast_test)
         auto l3 = p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
         p.add_instruction(migraphx::op::add{}, l1, l3);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape().packed());
         std::vector<float> results_vector(12);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -890,7 +890,7 @@ TEST_CASE(add_broadcast_test)
         auto l4 = p.add_instruction(migraphx::op::multibroadcast{{2, 2, 3}}, l2);
         p.add_instruction(migraphx::op::add{}, l3, l4);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         EXPECT(result.get_shape().packed());
         std::vector<float> results_vector(12);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -907,7 +907,7 @@ TEST_CASE(sub_test)
     auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
     p.add_instruction(migraphx::op::sub{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-2, -2, -2};
@@ -922,7 +922,7 @@ TEST_CASE(mul_test)
     auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
     p.add_instruction(migraphx::op::mul{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-1, 0, 3};
@@ -937,7 +937,7 @@ TEST_CASE(div_test)
     auto l2 = p.add_literal(migraphx::literal{s, {1.0f, 2.0f, 4.0f}});
     p.add_instruction(migraphx::op::div{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-1.f, 0.25f, 0.25f};
@@ -951,7 +951,7 @@ TEST_CASE(relu_test)
     auto l = p.add_literal(migraphx::literal{s, {-1.f, 0.f, 1.f}});
     p.add_instruction(migraphx::op::relu{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.f, 0.f, 1.f};
@@ -965,7 +965,7 @@ TEST_CASE(leaky_relu_test)
     auto l = p.add_literal(migraphx::literal{s, {-1.f, 0.f, 1.f}});
     p.add_instruction(migraphx::op::leaky_relu{0.01}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.01f, 0.f, 1.f};
@@ -979,7 +979,7 @@ TEST_CASE(lrn_test)
     auto l = p.add_literal(migraphx::literal{s, {-2.0f, 1.0f, 0.f, 1.0f, 2.0f}});
     p.add_instruction(migraphx::op::lrn{0.0001, 0.75, 1, 5}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(5);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-2 / 1.000075, 1 / 1.00009, 0 / 1.000145, 1 / 1.00009, 2 / 1.000075};
@@ -1013,7 +1013,7 @@ TEST_CASE(imagescaler_test)
     auto bias_bcast = p.add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
     p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.41,
@@ -1044,7 +1044,7 @@ TEST_CASE(reshape_test)
         std::vector<int64_t> new_shape = {8, 3, 1, 1};
         p.add_instruction(migraphx::op::reshape{new_shape}, l);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> results_vector(3);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(results_vector, data));
@@ -1055,7 +1055,7 @@ TEST_CASE(reshape_test)
         std::vector<int64_t> new_shape = {1, 3, 4, 2};
         p.add_instruction(migraphx::op::reshape{new_shape}, l);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> results_vector(3);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(results_vector, data));
@@ -1066,7 +1066,7 @@ TEST_CASE(reshape_test)
         std::vector<int64_t> new_shape = {1, 3, 4, 2};
         p.add_instruction(migraphx::op::reshape{new_shape}, l);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> results_vector(3);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(results_vector, data));
@@ -1118,7 +1118,7 @@ TEST_CASE(maxpool_test)
     auto al = p.add_literal(migraphx::literal{a_shape, a});
     p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{3, 2}}}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(36);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, c));
@@ -1133,7 +1133,7 @@ TEST_CASE(softmax_simple_test)
     auto al = p.add_literal(migraphx::literal{a_shape, a});
     p.add_instruction(migraphx::op::softmax{1}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, s));
@@ -1192,7 +1192,7 @@ TEST_CASE(softmax_test)
     auto al = p.add_literal(migraphx::literal{a_shape, a});
     p.add_instruction(migraphx::op::softmax{}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(120);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, s));
@@ -1225,7 +1225,7 @@ TEST_CASE(logsoftmax_test_axis_0)
     int axis = 0;
     p.add_instruction(migraphx::op::logsoftmax{axis}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, s));
@@ -1258,7 +1258,7 @@ TEST_CASE(logsoftmax_test_axis_1)
     int axis = 1;
     p.add_instruction(migraphx::op::logsoftmax{axis}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, s));
@@ -1291,7 +1291,7 @@ TEST_CASE(logsoftmax_test_axis_2)
     int axis = 2;
     p.add_instruction(migraphx::op::logsoftmax{axis}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, s));
@@ -1324,7 +1324,7 @@ TEST_CASE(logsoftmax_test_axis_3)
     int axis = 3;
     p.add_instruction(migraphx::op::logsoftmax{axis}, al);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify_range(results_vector, s));
@@ -1341,7 +1341,7 @@ TEST_CASE(argmax_test_0)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmax{0}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1359,7 +1359,7 @@ TEST_CASE(argmax_test_1)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmax{1}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1377,7 +1377,7 @@ TEST_CASE(argmax_test_neg_2)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmax{-2}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1395,7 +1395,7 @@ TEST_CASE(argmax_test_2)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmax{2}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1413,7 +1413,7 @@ TEST_CASE(argmin_test_0)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmin{0}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1431,7 +1431,7 @@ TEST_CASE(argmin_test_1)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmin{1}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1449,7 +1449,7 @@ TEST_CASE(argmin_test_2)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmin{2}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1467,7 +1467,7 @@ TEST_CASE(argmin_test_neg_1)
     auto dl = p.add_literal(migraphx::literal{data_shape, data});
     p.add_instruction(migraphx::op::argmin{-1}, dl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
@@ -1530,7 +1530,7 @@ TEST_CASE(conv2d_test)
 
     p.add_instruction(migraphx::op::convolution{}, al, cl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -1586,7 +1586,7 @@ TEST_CASE(conv2d_padding_test)
 
     p.add_instruction(migraphx::op::convolution{{{1, 1}}, {{1, 1}}}, al, cl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector(64);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -1647,7 +1647,7 @@ TEST_CASE(conv2d_padding_stride_test)
 
     p.add_instruction(migraphx::op::convolution{{{1, 1}}, {{2, 2}}}, al, cl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -1669,7 +1669,7 @@ TEST_CASE(quant_conv2d_test)
 
     p.add_instruction(migraphx::op::quant_convolution{}, al, cl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<int32_t> s = {10197,
                               10548,
@@ -1706,7 +1706,7 @@ TEST_CASE(quant_conv2d_padding_test)
     auto cl = p.add_literal(migraphx::literal{c_shape, c});
     p.add_instruction(migraphx::op::quant_convolution{{{1, 1}}, {{1, 1}}}, al, cl);
     p.compile(migraphx::cpu::target{});
-    auto result            = p.eval({});
+    auto result            = p.eval({}).back();
     std::vector<int32_t> s = {
         4521,  6753,  7014,  4635,  6858,  10197, 10548, 6939,  7830,  11601, 11952, 7839,  5007,
         7383,  7590,  4953,  10515, 15987, 16734, 11277, 16821, 25506, 26586, 17874, 19737, 29826,
@@ -1732,7 +1732,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
     auto cl = p.add_literal(migraphx::literal{c_shape, c});
     p.add_instruction(migraphx::op::quant_convolution{{{1, 1}}, {{2, 2}}}, al, cl);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<int32_t> s = {4521,
                               7014,
@@ -1770,7 +1770,7 @@ TEST_CASE(deconv_test)
 
     p.add_instruction(migraphx::op::deconvolution{}, x, w);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -1789,7 +1789,7 @@ TEST_CASE(transpose_test)
         std::vector<int64_t> perm = {0, 3, 1, 2};
         p.add_instruction(migraphx::op::transpose{perm}, l);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
 
         result.visit([&](auto output) {
             std::vector<size_t> new_lens = {1, 3, 2, 2};
@@ -1803,7 +1803,7 @@ TEST_CASE(transpose_test)
         auto result               = p.add_instruction(migraphx::op::transpose{perm}, l);
         p.add_instruction(migraphx::op::contiguous{}, result);
         p.compile(migraphx::cpu::target{});
-        auto result2 = p.eval({});
+        auto result2 = p.eval({}).back();
 
         std::vector<float> results_vector(12);
         result2.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -1822,7 +1822,7 @@ TEST_CASE(contiguous_test)
     auto l = p.add_literal(migraphx::literal{a_shape, data});
     p.add_instruction(migraphx::op::contiguous{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
 
     std::vector<float> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -1839,7 +1839,7 @@ TEST_CASE(identity_test)
     auto l = p.add_literal(migraphx::literal{s, data});
     p.add_instruction(migraphx::op::identity{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(std::equal(data.begin(), data.end(), results_vector.begin()));
@@ -1852,7 +1852,7 @@ TEST_CASE(abs_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 2, -3, 4}});
     p.add_instruction(migraphx::op::abs{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 2, 3, 4};
@@ -1866,7 +1866,7 @@ TEST_CASE(sigmoid_test)
     auto l = p.add_literal(migraphx::literal{s, {-1, 2, -3, 4}});
     p.add_instruction(migraphx::op::sigmoid{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{sigmoid(-1), sigmoid(2), sigmoid(-3), sigmoid(4)};
@@ -1880,7 +1880,7 @@ TEST_CASE(sinh_test)
     auto l = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
     p.add_instruction(migraphx::op::sinh{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{sinhf(-1), sinhf(2), sinhf(-3), sinhf(4)};
@@ -1894,7 +1894,7 @@ TEST_CASE(cosh_test)
     auto l = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
     p.add_instruction(migraphx::op::cosh{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{coshf(-1), coshf(2), coshf(-3), coshf(4)};
@@ -1908,7 +1908,7 @@ TEST_CASE(tanh_test)
     auto l = p.add_literal(migraphx::literal{s, {-1.0, 2.0, -3.0, 4.0}});
     p.add_instruction(migraphx::op::tanh{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{tanhf(-1), tanhf(2), tanhf(-3), tanhf(4)};
@@ -1923,7 +1923,7 @@ TEST_CASE(elu_test)
     float alpha = 0.5;
     p.add_instruction(migraphx::op::elu{alpha}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{elu(alpha, -1), elu(alpha, 2), elu(alpha, -3), elu(alpha, 4)};
@@ -1940,7 +1940,7 @@ TEST_CASE(max_test)
     auto curr_max = p.add_instruction(migraphx::op::max{}, l0, l1);
     p.add_instruction(migraphx::op::max{}, curr_max, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{7, 8, 9};
@@ -1957,7 +1957,7 @@ TEST_CASE(min_test)
     auto curr_min = p.add_instruction(migraphx::op::min{}, l0, l1);
     p.add_instruction(migraphx::op::min{}, curr_min, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 4, 3};
@@ -1971,7 +1971,7 @@ TEST_CASE(pad_test)
     auto l0 = p.add_literal(migraphx::literal{s, {1, 2, 3, 4}});
     p.add_instruction(migraphx::op::pad{{1, 1, 1, 1}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{0, 0, 0, 0, 0, 1, 2, 0, 0, 3, 4, 0, 0, 0, 0, 0};
@@ -1989,7 +1989,7 @@ TEST_CASE(fp16_test)
     auto l1 = p.add_literal(migraphx::literal{s, {b}});
     p.add_instruction(migraphx::op::add{}, l0, l1);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<migraphx::half> results_vector(1);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<migraphx::half> gold{c};
@@ -2014,7 +2014,7 @@ TEST_CASE(fp32_fp16_test)
         auto p                      = create_program();
         migraphx::quantize_fp16(p, op_names);
         p.compile(migraphx::cpu::target{});
-        auto result = p.eval({});
+        auto result = p.eval({}).back();
         std::vector<float> res;
         result.visit([&](auto output) { res.assign(output.begin(), output.end()); });
         EXPECT(migraphx::verify_range(res, gold_res));
@@ -2034,7 +2034,7 @@ TEST_CASE(clip_test)
     op.min_val = 0.0;
     p.add_instruction(op, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.0, 0.0, 6.0};
@@ -2049,7 +2049,7 @@ TEST_CASE(reduce_prod_axis0)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_prod{{0}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{6, 18, 12, 18};
@@ -2064,7 +2064,7 @@ TEST_CASE(reduce_sum_axis0)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_sum{{0}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{15, 18, 21, 24};
@@ -2079,7 +2079,7 @@ TEST_CASE(reduce_sum_axis1)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_sum{{1}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{4, 6, 12, 14, 20, 22};
@@ -2094,7 +2094,7 @@ TEST_CASE(reduce_sum_axis2)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_sum{{2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{3, 7, 11, 15, 19, 23};
@@ -2109,7 +2109,7 @@ TEST_CASE(reduce_sum_axis02)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_sum{{0, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{33, 45};
@@ -2124,7 +2124,7 @@ TEST_CASE(reduce_sum_axis12)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_sum{{1, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{10, 26, 42};
@@ -2138,7 +2138,7 @@ TEST_CASE(rsqrt_test)
     auto l = p.add_literal(migraphx::literal{s, {4.0, 16.0, 64.0}});
     p.add_instruction(migraphx::op::rsqrt{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.5, 0.25, 0.125};
@@ -2153,7 +2153,7 @@ TEST_CASE(reduce_mean_axis1)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_mean{{1}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{2, 3, 6, 7, 10, 11};
@@ -2168,7 +2168,7 @@ TEST_CASE(reduce_mean_axis2)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_mean{{2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1.5f, 3.5f, 5.5f, 7.5f, 9.5f, 11.5f};
@@ -2183,7 +2183,7 @@ TEST_CASE(reduce_mean_axis02)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_mean{{0, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{5.5, 7.5};
@@ -2198,7 +2198,7 @@ TEST_CASE(reduce_mean_axis12)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_mean{{1, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{2.5f, 6.5f, 10.5f};
@@ -2213,7 +2213,7 @@ TEST_CASE(reduce_mean_int)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_mean{{1, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<int> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int> gold{2, 6, 10};
@@ -2228,7 +2228,7 @@ TEST_CASE(reduce_min_axis1)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_min{{1}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 2, 5, 6, 9, 10};
@@ -2243,7 +2243,7 @@ TEST_CASE(reduce_min_axis02)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_min{{0, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 3};
@@ -2258,7 +2258,7 @@ TEST_CASE(reduce_min_axis12)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_min{{1, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 5, 9};
@@ -2273,7 +2273,7 @@ TEST_CASE(reduce_max_axis0)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_max{{0}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{9, 10, 11, 12};
@@ -2288,7 +2288,7 @@ TEST_CASE(reduce_max_axis01)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_max{{0, 1}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{11, 12};
@@ -2303,7 +2303,7 @@ TEST_CASE(reduce_max_axis02)
     auto l0    = p.add_literal(input);
     p.add_instruction(migraphx::op::reduce_max{{0, 2}}, l0);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{10, 12};
@@ -2318,7 +2318,7 @@ TEST_CASE(sqdiff_test)
     auto l2 = p.add_literal(migraphx::literal{s, {1, 2, 3}});
     p.add_instruction(migraphx::op::sqdiff{}, l1, l2);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {4, 4, 4};
@@ -2332,7 +2332,7 @@ TEST_CASE(round_test)
     auto l = p.add_literal(migraphx::literal{s, {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0}});
     p.add_instruction(migraphx::op::round{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {1.0, 2.0, 2.0, -1.0, -2.0, -2.0, 0.0, 2.0, -2.0};
@@ -2346,7 +2346,7 @@ TEST_CASE(ceil_test)
     auto l = p.add_literal(migraphx::literal{s, {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0}});
     p.add_instruction(migraphx::op::ceil{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {2.0, 2.0, 2.0, -1.0, -1.0, -1.0, 0.0, 2.0, -2.0};
@@ -2360,7 +2360,7 @@ TEST_CASE(floor_test)
     auto l = p.add_literal(migraphx::literal{s, {1.1, 1.5, 0.6, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0}});
     p.add_instruction(migraphx::op::floor{}, l);
     p.compile(migraphx::cpu::target{});
-    auto result = p.eval({});
+    auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {1.0, 1.0, 0.0, -2.0, -2.0, -1.0, -0.0, 2.0, -2.0};
@@ -2392,8 +2392,8 @@ TEST_CASE(op_capture)
     p.compile(migraphx::cpu::target{});
     capture_p.compile(migraphx::cpu::target{});
 
-    auto cap_res = capture_p.eval({});
-    auto res     = p.eval({});
+    auto cap_res = capture_p.eval({}).back();
+    auto res     = p.eval({}).back();
 
     std::vector<float> vec;
     std::vector<float> cap_vec;

test/cpu_rnn_ops_test.cpp

@@ -83,7 +83,7 @@ TEST_CASE(rnn_forward)
                           und,
                           ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -128,7 +128,7 @@ TEST_CASE(rnn_forward)
         p.add_instruction(migraphx::op::rnn_last_output{}, out_hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -165,7 +165,7 @@ TEST_CASE(rnn_forward)
         p.add_instruction(migraphx::op::rnn_last_output{}, out_hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -195,7 +195,7 @@ TEST_CASE(rnn_forward)
         p.add_instruction(migraphx::op::rnn_last_output{}, out_hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -230,7 +230,7 @@ TEST_CASE(rnn_forward)
                           und,
                           ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -311,7 +311,7 @@ TEST_CASE(rnn_reverse)
             und,
             ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -356,7 +356,7 @@ TEST_CASE(rnn_reverse)
         p.add_instruction(migraphx::op::rnn_last_output{}, out_hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -436,7 +436,7 @@ TEST_CASE(rnn_bidirectional)
             und,
             ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -475,7 +475,7 @@ TEST_CASE(rnn_bidirectional)
         p.add_instruction(migraphx::op::rnn_last_output{}, out_hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -520,7 +520,7 @@ TEST_CASE(rnn_bidirectional)
         p.add_instruction(migraphx::op::rnn_last_output{}, out_hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -560,7 +560,7 @@ TEST_CASE(rnn_bidirectional)
                           r);
         p.compile(migraphx::cpu::target{});
 
-        auto last_output = p.eval({});
+        auto last_output = p.eval({}).back();
         std::vector<float> last_output_data;
         last_output.visit([&](auto out) { last_output_data.assign(out.begin(), out.end()); });
 
@@ -596,7 +596,7 @@ TEST_CASE(rnn_bidirectional)
             und,
             ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -699,7 +699,7 @@ TEST_CASE(gru_forward)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -736,7 +736,7 @@ TEST_CASE(gru_forward)
                               ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -778,7 +778,7 @@ TEST_CASE(gru_forward)
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -819,7 +819,7 @@ TEST_CASE(gru_forward)
                               ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -911,7 +911,7 @@ TEST_CASE(gru_forward_args)
                           r);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -943,7 +943,7 @@ TEST_CASE(gru_forward_args)
                           bias);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -978,7 +978,7 @@ TEST_CASE(gru_forward_args)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1069,7 +1069,7 @@ TEST_CASE(gru_forward_actv_funcs)
             ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1108,7 +1108,7 @@ TEST_CASE(gru_forward_actv_funcs)
                           und,
                           ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1142,7 +1142,7 @@ TEST_CASE(gru_forward_actv_funcs)
             ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1186,7 +1186,7 @@ TEST_CASE(gru_forward_actv_funcs)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1284,7 +1284,7 @@ TEST_CASE(gru_reverse)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1321,7 +1321,7 @@ TEST_CASE(gru_reverse)
                               ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1362,7 +1362,7 @@ TEST_CASE(gru_reverse)
                               ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1398,7 +1398,7 @@ TEST_CASE(gru_reverse)
             und,
             ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1438,7 +1438,7 @@ TEST_CASE(gru_reverse)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1554,7 +1554,7 @@ TEST_CASE(gru_bidirectional)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1595,7 +1595,7 @@ TEST_CASE(gru_bidirectional)
                               ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1630,7 +1630,7 @@ TEST_CASE(gru_bidirectional)
                               ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1734,7 +1734,7 @@ TEST_CASE(gru_bidirectional_args)
                           r);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1770,7 +1770,7 @@ TEST_CASE(gru_bidirectional_args)
                           bias);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1809,7 +1809,7 @@ TEST_CASE(gru_bidirectional_args)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1921,7 +1921,7 @@ TEST_CASE(gru_bidirectional_actv_funcs)
             ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1954,7 +1954,7 @@ TEST_CASE(gru_bidirectional_actv_funcs)
                           und,
                           ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -1991,7 +1991,7 @@ TEST_CASE(gru_bidirectional_actv_funcs)
                           und,
                           ih);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2032,7 +2032,7 @@ TEST_CASE(gru_bidirectional_actv_funcs)
             ih);
         p.add_instruction(migraphx::op::rnn_last_output{}, concat_hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2068,7 +2068,7 @@ TEST_CASE(gru_bidirectional_actv_funcs)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2112,7 +2112,7 @@ TEST_CASE(gru_bidirectional_actv_funcs)
                           ih);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2236,7 +2236,7 @@ TEST_CASE(lstm_forward)
             und);
         p.compile(migraphx::cpu::target{});
 
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2280,7 +2280,7 @@ TEST_CASE(lstm_forward)
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_hs = p.eval({});
+        auto last_hs = p.eval({}).back();
         std::vector<float> output_data;
         last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
 
@@ -2328,7 +2328,7 @@ TEST_CASE(lstm_forward)
         p.add_instruction(migraphx::op::lstm_last_cell_output{}, hs);
         p.compile(migraphx::cpu::target{});
 
-        auto last_hs = p.eval({});
+        auto last_hs = p.eval({}).back();
         std::vector<float> output_data;
         last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
 
@@ -2449,7 +2449,7 @@ TEST_CASE(lstm_forward_more)
             r);
         p.compile(migraphx::cpu::target{});
 
-        auto last_hs = p.eval({});
+        auto last_hs = p.eval({}).back();
         std::vector<float> output_data;
         last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
 
@@ -2493,7 +2493,7 @@ TEST_CASE(lstm_forward_more)
             pph);
         p.compile(migraphx::cpu::target{});
 
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2542,7 +2542,7 @@ TEST_CASE(lstm_forward_more)
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
 
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> hs_data;
         hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
 
@@ -2672,7 +2672,7 @@ TEST_CASE(lstm_reverse)
             ic,
             pph);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -2704,7 +2704,7 @@ TEST_CASE(lstm_reverse)
         p.add_instruction(migraphx::op::lstm_last_cell_output{}, hs);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{-0.443077,
@@ -2736,7 +2736,7 @@ TEST_CASE(lstm_reverse)
         p.add_instruction(migraphx::op::lstm_last_cell_output{}, hs);
 
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{-0.443077,
@@ -2753,8 +2753,91 @@ TEST_CASE(lstm_reverse)
                                             0.667298};
         EXPECT(migraphx::verify_range(output_data, output_data_gold));
     }
+}
+
+// lstm activation function test
+TEST_CASE(lstm_reverse_actv)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 1;
+    std::vector<float> w_data{
+        -0.2763, -0.4715, -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,
+        -0.1843, 0.2351,  0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914,
+        -0.1480, 0.3734,  -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401,
+        0.1486,  0.1346,  0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,
+        -0.4462, 0.0729,  0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+
+    std::vector<float> r_data{
+        -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,  0.2824,  0.4775,  -0.2729, -0.4707,
+        0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,  0.3794,  -0.1069, -0.3049, 0.1430,
+        -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,  0.2891,  0.1786,  -0.3274, 0.2365,
+        0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154, 0.2851,  -0.3930, -0.1174, 0.4360,
+        0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459, -0.2991, -0.2624, 0.4194,  -0.3291,
+        -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584, 0.2596,  0.2871,  -0.3509, -0.1910,
+        0.3987,  -0.1687, -0.0032, -0.1038};
+
+    std::vector<float> bias_data{-0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,
+                                 -0.1823, 0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,
+                                 0.4755,  -0.4794, 0.2167,  -0.4474, -0.3139, 0.1018,  0.4470,
+                                 -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
+                                 -0.4386, 0.4208,  0.0717,  0.3789};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930,  -0.5221, -0.1331,
+        -0.0910, 1.2122, -0.1952, 0.4661,  0.6494,  2.1332,  -1.0972, 0.9816,  0.1122,
+        0.3577,  1.3508, -0.5366, 1.7449,  0.5483,  -0.0701, -0.4100, -2.2344, 0.3685,
+        0.4583,  2.3794, 1.0372,  -0.8887, 0.7892,  -0.4012, -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.5289,
+                               1.0986,
+                               0.6091,
+                               1.6462,
+                               0.8720,
+                               0.5349,
+                               -0.1962,
+                               -1.7416,
+                               -0.9912,
+                               1.2831,
+                               1.0896,
+                               -0.6959};
 
-    // reverse, 3 args, 1 actv function
+    std::vector<float> ic_data{-0.8323,
+                               0.3998,
+                               0.1831,
+                               0.5938,
+                               2.7096,
+                               -0.1790,
+                               0.0022,
+                               -0.8040,
+                               0.1578,
+                               0.0567,
+                               0.8069,
+                               -0.5141};
+
+    std::vector<float> pph_data{-0.8271,
+                                -0.5683,
+                                0.4562,
+                                -1.2545,
+                                1.2729,
+                                -0.4082,
+                                -0.4392,
+                                -0.9406,
+                                0.7794,
+                                1.8194,
+                                -0.5811,
+                                0.2166};
+
+    migraphx::shape in_shape{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+    float clip = 0.0f;
     {
         migraphx::program p;
         auto seq = p.add_literal(migraphx::literal{in_shape, input_data});
@@ -2770,7 +2853,7 @@ TEST_CASE(lstm_reverse)
                           w,
                           r);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -2801,7 +2884,7 @@ TEST_CASE(lstm_reverse)
                               r);
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{-0.132123,
@@ -2842,7 +2925,7 @@ TEST_CASE(lstm_reverse)
             w,
             r);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{-0.104351,
@@ -2961,7 +3044,7 @@ TEST_CASE(lstm_bidirectional)
             ic,
             pph);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3010,7 +3093,7 @@ TEST_CASE(lstm_bidirectional)
             pph);
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3048,7 +3131,7 @@ TEST_CASE(lstm_bidirectional)
             pph);
         p.add_instruction(migraphx::op::lstm_last_cell_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3075,7 +3158,7 @@ TEST_CASE(lstm_bidirectional)
             w,
             r);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3117,7 +3200,7 @@ TEST_CASE(lstm_bidirectional)
             w,
             r);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3186,7 +3269,7 @@ TEST_CASE(lstm_bidirectional_actv_func)
             w,
             r);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3222,7 +3305,7 @@ TEST_CASE(lstm_bidirectional_actv_func)
                           w,
                           r);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3258,7 +3341,7 @@ TEST_CASE(lstm_bidirectional_actv_func)
                               r);
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3288,7 +3371,7 @@ TEST_CASE(lstm_bidirectional_actv_func)
                                     r);
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3319,7 +3402,7 @@ TEST_CASE(lstm_bidirectional_actv_func)
                                     r);
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
@@ -3351,7 +3434,7 @@ TEST_CASE(lstm_bidirectional_actv_func)
                                     r);
         p.add_instruction(migraphx::op::rnn_last_output{}, hs);
         p.compile(migraphx::cpu::target{});
-        auto hs_concat = p.eval({});
+        auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_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);
 }