Merge branch 'master' into remove_concat

src/targets/gpu/target.cpp

@@ -58,10 +58,6 @@ std::vector<pass> target::get_passes(migraph::context& gctx) const
 
 std::string target::name() const { return "miopen"; }
 
-migraph::context target::get_context() const
-{
-    return context{
-        share(make_obj<miopen_handle>(&miopenCreate)), share(create_rocblas_handle_ptr()), {}};
-}
+migraph::context target::get_context() const { return context{}; }
 } // namespace gpu
 } // namespace migraph

test/CMakeLists.txt

@@ -7,7 +7,7 @@ find_package(Threads REQUIRED)
 include(ProcessorCount)
 ProcessorCount(N)
 set(CTEST_PARALLEL_LEVEL ${N} CACHE STRING "CTest parallel level")
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -j ${CTEST_PARALLEL_LEVEL} -C ${CMAKE_CFG_INTDIR})
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -j ${CTEST_PARALLEL_LEVEL} -C ${CMAKE_CFG_INTDIR} --timeout 1500)
 add_custom_target(tests)
 
 find_program(MIGRAPH_GDB gdb)
@@ -103,7 +103,10 @@ if(MIGRAPH_ENABLE_GPU)
         get_filename_component(BASE_NAME ${TEST} NAME_WE)
         add_test_executable(test_gpu_${BASE_NAME} ${TEST})
         rocm_clang_tidy_check(test_gpu_${BASE_NAME})
-        set_tests_properties(test_gpu_${BASE_NAME} PROPERTIES COST 10)
+        set_tests_properties(test_gpu_${BASE_NAME} PROPERTIES 
+            COST 10 
+            RESOURCE_LOCK gpu
+        )
         target_link_libraries(test_gpu_${BASE_NAME} migraph_gpu)
     endforeach()
 endif()

test/cpu_ops_test.cpp

@@ -3,7 +3,7 @@
 #include <migraph/literal.hpp>
 #include <migraph/operators.hpp>
 #include <migraph/instruction.hpp>
-#include <migraph/cpu/cpu_target.hpp>
+#include <migraph/cpu/target.hpp>
 #include <migraph/verify.hpp>
 #include "test.hpp"
 
@@ -18,7 +18,7 @@ void slice_test()
         p.add_instruction(migraph::op::slice{{2}, {1}, {3}}, l0);
         migraph::shape s2{migraph::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
         EXPECT(p.get_shape() == s2);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         migraph::shape sresult{migraph::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
         auto result           = p.eval({});
         std::vector<int> gold = {1, 2, 4, 5, 7, 8, 10, 11};
@@ -36,7 +36,7 @@ void slice_test()
         p.add_instruction(migraph::op::slice{{0, 1, 2}, {0, 0, 0}, {2, 2, 2}}, l0);
         migraph::shape s2{migraph::shape::int32_type, {2, 2, 2}, {6, 3, 1}};
         EXPECT(p.get_shape() == s2);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         migraph::shape sresult{migraph::shape::int32_type, {2, 2, 2}, {4, 2, 1}};
         auto result           = p.eval({});
         std::vector<int> gold = {0, 1, 3, 4, 6, 7, 9, 10};
@@ -62,7 +62,7 @@ void concat_test()
         auto l1 = p.add_literal(migraph::literal{s1, data1});
         auto l2 = p.add_literal(migraph::literal{s2, data2});
         p.add_instruction(migraph::op::concat{axis}, l0, l1, l2);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result           = p.eval({});
         std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
         std::vector<int> results_vector(2 * 6);
@@ -85,7 +85,7 @@ void concat_test()
         auto l1 = p.add_literal(migraph::literal{s1, data1});
         auto l2 = p.add_literal(migraph::literal{s2, data2});
         p.add_instruction(migraph::op::concat{axis}, l0, l1, l2);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result           = p.eval({});
         std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
         std::vector<int> results_vector(6 * 2);
@@ -106,7 +106,7 @@ void squeeze_test()
         migraph::shape s2{migraph::shape::float_type, {4, 3, 1, 3}};
         auto l0 = p.add_literal(migraph::literal{s1, data});
         p.add_instruction(migraph::op::squeeze{{1}}, l0);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         EXPECT(result.get_shape() == s2);
     }
@@ -117,7 +117,7 @@ void squeeze_test()
         migraph::shape s2{migraph::shape::float_type, {4, 1, 3, 3}};
         auto l0 = p.add_literal(migraph::literal{s1, data});
         p.add_instruction(migraph::op::squeeze{{3}}, l0);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         EXPECT(result.get_shape() == s2);
     }
@@ -128,7 +128,7 @@ void squeeze_test()
         migraph::shape s2{migraph::shape::float_type, {4, 3, 3}};
         auto l0 = p.add_literal(migraph::literal{s1, data});
         p.add_instruction(migraph::op::squeeze{}, l0);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         EXPECT(result.get_shape() == s2);
     }
@@ -143,7 +143,7 @@ void unsqueeze_test()
         migraph::shape s2{migraph::shape::float_type, {4, 1, 3, 3}};
         auto l0 = p.add_literal(migraph::literal{s1, data});
         p.add_instruction(migraph::op::unsqueeze{{1}}, l0);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         EXPECT(result.get_shape() == s2);
     }
@@ -154,12 +154,52 @@ void unsqueeze_test()
         migraph::shape s2{migraph::shape::float_type, {4, 3, 1, 3}};
         auto l0 = p.add_literal(migraph::literal{s1, data});
         p.add_instruction(migraph::op::unsqueeze{{2}}, l0);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         EXPECT(result.get_shape() == s2);
     }
 }
 
+void globalavgpool_test()
+{
+    migraph::program p;
+    auto s     = migraph::shape{migraph::shape::float_type, {1, 3, 2, 2}};
+    auto op    = migraph::op::pooling{"average"};
+    auto lens  = s.lens();
+    op.lengths = {lens[2], lens[3]};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = p.add_literal(migraph::literal{s, data});
+    p.add_instruction(op, l0);
+    p.compile(migraph::cpu::target{});
+    auto result = p.eval({});
+
+    std::vector<float> results_vector(3);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.25, 0.575, 0.375};
+    EXPECT(migraph::verify_range(results_vector, gold));
+}
+
+void globalmaxpool_test()
+{
+    migraph::program p;
+    auto s     = migraph::shape{migraph::shape::float_type, {1, 3, 2, 2}};
+    auto op    = migraph::op::pooling{"max"};
+    auto lens  = s.lens();
+    op.lengths = {lens[2], lens[3]};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = p.add_literal(migraph::literal{s, data});
+    p.add_instruction(op, l0);
+    p.compile(migraph::cpu::target{});
+    auto result = p.eval({});
+
+    std::vector<float> results_vector(3);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.4, 0.9, 0.7};
+    EXPECT(migraph::verify_range(results_vector, gold));
+}
+
 void im2col_3x3_no_pad_identity_test()
 {
     std::size_t f[2]    = {3, 3};
@@ -179,7 +219,7 @@ void im2col_3x3_no_pad_identity_test()
     auto l_image   = p.add_literal(migraph::literal{s_image, input});
     auto l_weights = p.add_literal(migraph::literal{s_weights, weights});
     p.add_instruction(migraph::op::im2col{padding, stride, dilation}, l_image, l_weights);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
@@ -208,7 +248,7 @@ void im2col_3x3_no_pad_test()
     auto l_image   = p.add_literal(migraph::literal{s_image, input});
     auto l_weights = p.add_literal(migraph::literal{s_weights, weights});
     p.add_instruction(migraph::op::im2col{padding, stride, dilation}, l_image, l_weights);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<int> correct = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
@@ -240,7 +280,7 @@ void im2col_3x3_stride_2_no_pad_test()
     auto l_image   = p.add_literal(migraph::literal{s_image, input});
     auto l_weights = p.add_literal(migraph::literal{s_weights, weights});
     p.add_instruction(migraph::op::im2col{padding, stride, dilation}, l_image, l_weights);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<int> correct = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
@@ -273,7 +313,7 @@ void im2col_3x3_with_padding_test()
     auto l_image   = p.add_literal(migraph::literal{s_image, input});
     auto l_weights = p.add_literal(migraph::literal{s_weights, weights});
     p.add_instruction(migraph::op::im2col{padding, stride, dilation}, l_image, l_weights);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<int> correct = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
@@ -315,7 +355,7 @@ void batch_norm_inference_test()
     auto variance = p.add_literal(migraph::literal{vars, variance_data});
 
     p.add_instruction(migraph::op::batch_norm_inference{}, x, scale, bias, mean, variance);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<float> result_vector(width * height * channels * batches);
@@ -345,7 +385,7 @@ void im2col_3x3_with_channels_identity_test()
     auto l_image   = p.add_literal(migraph::literal{s_image, input});
     auto l_weights = p.add_literal(migraph::literal{s_weights, weights});
     p.add_instruction(migraph::op::im2col{padding, stride, dilation}, l_image, l_weights);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
@@ -361,7 +401,7 @@ void exp_test()
     migraph::shape s{migraph::shape::float_type, {3}};
     auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     p.add_instruction(migraph::op::exp{}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -375,7 +415,7 @@ void sin_test()
     migraph::shape s{migraph::shape::float_type, {3}};
     auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     p.add_instruction(migraph::op::sin{}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -389,7 +429,7 @@ void cos_test()
     migraph::shape s{migraph::shape::float_type, {3}};
     auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     p.add_instruction(migraph::op::cos{}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -403,7 +443,7 @@ void tan_test()
     migraph::shape s{migraph::shape::float_type, {3}};
     auto l = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     p.add_instruction(migraph::op::tan{}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -418,7 +458,7 @@ void add_test()
     auto l1 = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     auto l2 = p.add_literal(migraph::literal{s, {1, 2, 3}});
     p.add_instruction(migraph::op::add{}, l1, l2);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -437,7 +477,7 @@ void broadcast_test()
     auto l1       = p.add_literal(migraph::literal{a_shape, a_data});
     auto l2       = p.add_literal(migraph::literal{b_shape, b_data});
     p.add_instruction(migraph::op::broadcast{axis, l1->get_shape()}, l2);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     auto output = result.get<int32_t>();
     EXPECT(output(0, 0) == -2);
@@ -457,7 +497,7 @@ void add_broadcast_test()
     auto l2       = p.add_literal(migraph::literal{b_shape, b_data});
     auto l3       = p.add_instruction(migraph::op::broadcast{axis, l1->get_shape()}, l2);
     p.add_instruction(migraph::op::add{}, l1, l3);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     EXPECT(result.get_shape().packed());
     std::vector<float> results_vector(12);
@@ -473,7 +513,7 @@ void sub_test()
     auto l1 = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     auto l2 = p.add_literal(migraph::literal{s, {1, 2, 3}});
     p.add_instruction(migraph::op::sub{}, l1, l2);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -488,7 +528,7 @@ void mul_test()
     auto l1 = p.add_literal(migraph::literal{s, {-1, 0, 1}});
     auto l2 = p.add_literal(migraph::literal{s, {1, 2, 3}});
     p.add_instruction(migraph::op::mul{}, l1, l2);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -503,7 +543,7 @@ void div_test()
     auto l1 = p.add_literal(migraph::literal{s, {-1.0f, 0.5f, 1.0f}});
     auto l2 = p.add_literal(migraph::literal{s, {1.0f, 2.0f, 4.0f}});
     p.add_instruction(migraph::op::div{}, l1, l2);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -517,7 +557,7 @@ void relu_test()
     migraph::shape s{migraph::shape::float_type, {3}};
     auto l = p.add_literal(migraph::literal{s, {-1.f, 0.f, 1.f}});
     p.add_instruction(migraph::op::activation{"relu"}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -531,7 +571,7 @@ void leaky_relu_test()
     migraph::shape s{migraph::shape::float_type, {3}};
     auto l = p.add_literal(migraph::literal{s, {-1.f, 0.f, 1.f}});
     p.add_instruction(migraph::op::leaky_relu{0.01}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -539,6 +579,53 @@ void leaky_relu_test()
     EXPECT(migraph::verify_range(results_vector, gold));
 }
 
+void imagescaler_test()
+{
+    migraph::program p;
+    migraph::shape s{migraph::shape::float_type, {1, 3, 2, 2}};
+    auto img           = p.add_literal(migraph::literal{s,
+                                              {0.2,
+                                               0.3,
+                                               0.5,
+                                               0.4,
+
+                                               0.7,
+                                               0.8,
+                                               0.1,
+                                               0.9,
+
+                                               0.15,
+                                               0.25,
+                                               0.35,
+                                               0.45}});
+    auto scale_val     = p.add_literal(2.f);
+    auto scaled_tensor = p.add_instruction(migraph::op::scalar{s}, scale_val);
+    auto img_scaled    = p.add_instruction(migraph::op::mul{}, img, scaled_tensor);
+    auto bias_vals     = p.add_literal(
+        migraph::literal{migraph::shape{migraph::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
+    auto bias_bcast = p.add_instruction(migraph::op::broadcast{1, s}, bias_vals);
+    p.add_instruction(migraph::op::add{}, img_scaled, bias_bcast);
+    p.compile(migraph::cpu::target{});
+    auto result = p.eval({});
+    std::vector<float> results_vector(12);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0.41,
+                               0.61,
+                               1.01,
+                               0.81,
+
+                               1.42,
+                               1.62,
+                               0.22,
+                               1.82,
+
+                               0.33,
+                               0.53,
+                               0.73,
+                               0.93};
+    EXPECT(migraph::verify_range(results_vector, gold));
+}
+
 void reshape_test()
 {
     migraph::shape a_shape{migraph::shape::float_type, {24, 1, 1, 1}};
@@ -549,7 +636,7 @@ void reshape_test()
         auto l                         = p.add_literal(migraph::literal{a_shape, data});
         std::vector<int64_t> new_shape = {8, 3, 1, 1};
         p.add_instruction(migraph::op::reshape{new_shape}, l);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         std::vector<float> results_vector(3);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -560,7 +647,7 @@ void reshape_test()
         auto l                         = p.add_literal(migraph::literal{a_shape, data});
         std::vector<int64_t> new_shape = {1, 3, 4, 2};
         p.add_instruction(migraph::op::reshape{new_shape}, l);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         std::vector<float> results_vector(3);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -571,7 +658,7 @@ void reshape_test()
         auto l                         = p.add_literal(migraph::literal{a_shape, data});
         std::vector<int64_t> new_shape = {1, 3, 4, 2};
         p.add_instruction(migraph::op::reshape{new_shape}, l);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
         std::vector<float> results_vector(3);
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -618,8 +705,8 @@ void gemm_test()
     auto al = p.add_literal(migraph::literal{a_shape, a});
     migraph::shape b_shape{migraph::shape::get_type<T>{}, {5, 3}};
     auto bl = p.add_literal(migraph::literal{b_shape, b});
-    p.add_instruction(migraph::op::gemm{}, al, bl);
-    p.compile(migraph::cpu::cpu_target{});
+    p.add_instruction(migraph::op::dot{}, al, bl);
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<T> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -674,7 +761,7 @@ void maxpool_test()
     migraph::shape a_shape{migraph::shape::float_type, {2, 3, 6, 6}};
     auto al = p.add_literal(migraph::literal{a_shape, a});
     p.add_instruction(migraph::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{3, 2}}}, al);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::cout << result.get_shape() << std::endl;
     std::vector<float> results_vector(36);
@@ -739,7 +826,7 @@ void softmax_test()
     migraph::shape a_shape{migraph::shape::float_type, {5, 3, 4, 2}};
     auto al = p.add_literal(migraph::literal{a_shape, a});
     p.add_instruction(migraph::op::softmax{}, al);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
     std::vector<float> results_vector(120);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
@@ -801,7 +888,7 @@ void conv2d_test()
     auto cl = p.add_literal(migraph::literal{c_shape, c});
 
     p.add_instruction(migraph::op::convolution{}, al, cl);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<float> results_vector(16);
@@ -857,7 +944,7 @@ void conv2d_padding_test()
     auto cl = p.add_literal(migraph::literal{c_shape, c});
 
     p.add_instruction(migraph::op::convolution{{{1, 1}}, {{1, 1}}}, al, cl);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<float> results_vector(64);
@@ -918,7 +1005,7 @@ void conv2d_padding_stride_test()
     auto cl = p.add_literal(migraph::literal{c_shape, c});
 
     p.add_instruction(migraph::op::convolution{{{1, 1}}, {{2, 2}}}, al, cl);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<float> results_vector(16);
@@ -937,7 +1024,7 @@ void transpose_test()
         auto l                    = p.add_literal(migraph::literal{a_shape, data});
         std::vector<int64_t> perm = {0, 3, 1, 2};
         p.add_instruction(migraph::op::transpose{perm}, l);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result = p.eval({});
 
         result.visit([&](auto output) {
@@ -951,7 +1038,7 @@ void transpose_test()
         std::vector<int64_t> perm = {0, 3, 1, 2};
         auto result               = p.add_instruction(migraph::op::transpose{perm}, l);
         p.add_instruction(migraph::op::contiguous{}, result);
-        p.compile(migraph::cpu::cpu_target{});
+        p.compile(migraph::cpu::target{});
         auto result2 = p.eval({});
 
         std::vector<float> results_vector(12);
@@ -970,7 +1057,7 @@ void contiguous_test()
     migraph::program p;
     auto l = p.add_literal(migraph::literal{a_shape, data});
     p.add_instruction(migraph::op::contiguous{}, l);
-    p.compile(migraph::cpu::cpu_target{});
+    p.compile(migraph::cpu::target{});
     auto result = p.eval({});
 
     std::vector<float> results_vector(12);
@@ -994,6 +1081,7 @@ int main()
     add_test();
     broadcast_test();
     add_broadcast_test();
+    imagescaler_test();
     sub_test();
     mul_test();
     div_test();
@@ -1010,6 +1098,8 @@ int main()
     conv2d_padding_test();
     conv2d_padding_stride_test();
     batch_norm_inference_test();
+    globalavgpool_test();
+    globalmaxpool_test();
     im2col_3x3_no_pad_identity_test();
     im2col_3x3_no_pad_test();
     im2col_3x3_stride_2_no_pad_test();

test/dead_code_elimination_test.cpp

@@ -43,6 +43,22 @@ void simple_test_nop()
     EXPECT(result != migraph::literal{4});
 }
 
+void simple_test_nop2()
+{
+    migraph::program p;
+
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    p.add_instruction(nop{});
+    p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(nop{});
+    p.compile(dce_target{});
+    EXPECT(std::distance(p.begin(), p.end()) == 2);
+    auto result = p.eval({});
+    EXPECT(result == migraph::literal{});
+    EXPECT(result != migraph::literal{4});
+}
+
 void duplicate_test1()
 {
     migraph::program p;
@@ -99,6 +115,7 @@ int main()
 {
     simple_test();
     simple_test_nop();
+    simple_test_nop2();
     duplicate_test1();
     duplicate_test2();
     depth_test();

test/fwd_conv_batchnorm_rewrite_test.cpp

 #include <migraph/fwd_conv_batchnorm_rewrite.hpp>
 #include <migraph/program.hpp>
-#include <migraph/cpu/cpu_target.hpp>
+#include <migraph/cpu/target.hpp>
 #include <migraph/operators.hpp>
 #include <migraph/instruction.hpp>
 #include <test.hpp>
@@ -51,8 +51,8 @@ void fwd_conv_batchnorm_rewrite_test()
     migraph::program p2 = create_program();
     migraph::fwd_conv_batchnorm_rewrite opt;
     opt.apply(p2);
-    p1.compile(migraph::cpu::cpu_target{});
-    p2.compile(migraph::cpu::cpu_target{});
+    p1.compile(migraph::cpu::target{});
+    p2.compile(migraph::cpu::target{});
 
     auto result1 = p1.eval({});
     auto result2 = p2.eval({});

test/gpu/miopen.cpp

@@ -2,7 +2,7 @@
 #include <migraph/program.hpp>
 #include <migraph/operators.hpp>
 #include <migraph/generate.hpp>
-#include <migraph/cpu/cpu_target.hpp>
+#include <migraph/cpu/target.hpp>
 #include <migraph/gpu/target.hpp>
 #include <migraph/gpu/miopen.hpp>
 #include <migraph/gpu/hip.hpp>
@@ -100,7 +100,7 @@ migraph::argument run_cpu(migraph::program& p)
     V v;
     p = v.create_program();
     auto_print pp{p, 0};
-    compile_check(p, migraph::cpu::cpu_target{});
+    compile_check(p, migraph::cpu::target{});
     migraph::program::parameter_map m;
     for(auto&& x : p.get_parameter_shapes())
     {
@@ -129,11 +129,13 @@ template <class V>
 void verify_program()
 {
     auto_print::set_terminate_handler(migraph::get_type_name<V>());
+    // std::cout << migraph::get_type_name<V>() << std::endl;
     migraph::program cpu_prog;
     migraph::program gpu_prog;
     auto cpu_arg_f = detach_async([&] { return run_cpu<V>(cpu_prog); });
     auto gpu_arg   = run_gpu<V>(gpu_prog);
-    bool passed    = verify_args(migraph::get_type_name<V>(), cpu_arg_f.get(), gpu_arg);
+    auto cpu_arg   = cpu_arg_f.get();
+    bool passed    = verify_args(migraph::get_type_name<V>(), cpu_arg, gpu_arg);
     if(not passed)
     {
         V v;
@@ -174,6 +176,46 @@ struct test_add
     }
 };
 
+struct test_add_half
+{
+    migraph::program create_program() const
+    {
+        migraph::program p;
+        migraph::shape s{migraph::shape::half_type, {3}};
+        auto x = p.add_parameter("x", s);
+        auto y = p.add_parameter("y", s);
+        p.add_instruction(migraph::op::add{}, x, y);
+        return p;
+    }
+};
+
+struct test_mul
+{
+    migraph::program create_program() const
+    {
+        migraph::program p;
+        migraph::shape s{migraph::shape::float_type, {3}};
+        auto x = p.add_parameter("x", s);
+        auto y = p.add_parameter("y", s);
+        p.add_instruction(migraph::op::mul{}, x, y);
+        return p;
+    }
+};
+
+struct test_scale
+{
+    migraph::program create_program() const
+    {
+        migraph::program p;
+        migraph::shape s{migraph::shape::float_type, {3}};
+        auto x     = p.add_parameter("x", s);
+        auto y     = p.add_parameter("y", migraph::shape::float_type);
+        auto scale = p.add_instruction(migraph::op::scalar{s}, y);
+        p.add_instruction(migraph::op::mul{}, x, scale);
+        return p;
+    }
+};
+
 struct test_triadd
 {
     migraph::program create_program() const
@@ -355,6 +397,20 @@ struct test_conv_relu
     }
 };
 
+struct test_conv_relu_half
+{
+    migraph::program create_program() const
+    {
+        migraph::program p;
+        auto input = p.add_parameter("x", migraph::shape{migraph::shape::half_type, {4, 3, 3, 3}});
+        auto weights =
+            p.add_parameter("w", migraph::shape{migraph::shape::half_type, {4, 3, 3, 3}});
+        auto conv = p.add_instruction(migraph::op::convolution{}, input, weights);
+        p.add_instruction(migraph::op::activation{"relu"}, conv);
+        return p;
+    }
+};
+
 struct test_add_relu
 {
     migraph::program create_program() const
@@ -395,6 +451,36 @@ struct test_conv_pooling
     }
 };
 
+struct test_global_avg_pooling
+{
+    migraph::program create_program() const
+    {
+        migraph::program p;
+        auto input =
+            p.add_parameter("x", migraph::shape{migraph::shape::float_type, {1, 3, 16, 16}});
+        auto op    = migraph::op::pooling{"average"};
+        auto lens  = input->get_shape().lens();
+        op.lengths = {lens[2], lens[3]};
+        p.add_instruction(op, input);
+        return p;
+    }
+};
+
+struct test_global_max_pooling
+{
+    migraph::program create_program() const
+    {
+        migraph::program p;
+        auto input =
+            p.add_parameter("x", migraph::shape{migraph::shape::float_type, {1, 3, 16, 16}});
+        auto op    = migraph::op::pooling{"max"};
+        auto lens  = input->get_shape().lens();
+        op.lengths = {lens[2], lens[3]};
+        p.add_instruction(op, input);
+        return p;
+    }
+};
+
 struct test_gemm
 {
     migraph::program create_program() const
@@ -402,7 +488,7 @@ struct test_gemm
         migraph::program p;
         auto a = p.add_parameter("a", migraph::shape{migraph::shape::float_type, {4, 5}});
         auto b = p.add_parameter("b", migraph::shape{migraph::shape::float_type, {5, 3}});
-        p.add_instruction(migraph::op::gemm{}, a, b);
+        p.add_instruction(migraph::op::dot{}, a, b);
         return p;
     }
 };
@@ -414,7 +500,7 @@ struct test_gemm_ld
         migraph::program p;
         auto a = p.add_parameter("a", migraph::shape{migraph::shape::float_type, {4, 5}, {10, 1}});
         auto b = p.add_parameter("b", migraph::shape{migraph::shape::float_type, {5, 3}, {20, 1}});
-        p.add_instruction(migraph::op::gemm{}, a, b);
+        p.add_instruction(migraph::op::dot{}, a, b);
         return p;
     }
 };
@@ -427,7 +513,7 @@ struct test_gemm_transposeb
         auto a  = p.add_parameter("a", migraph::shape{migraph::shape::float_type, {4, 5}});
         auto b  = p.add_parameter("b", migraph::shape{migraph::shape::float_type, {3, 5}});
         auto bt = p.add_instruction(migraph::op::transpose{{1, 0}}, b);
-        p.add_instruction(migraph::op::gemm{}, a, bt);
+        p.add_instruction(migraph::op::dot{}, a, bt);
         return p;
     }
 };
@@ -440,7 +526,7 @@ struct test_gemm_transposea
         auto a  = p.add_parameter("a", migraph::shape{migraph::shape::float_type, {5, 4}});
         auto b  = p.add_parameter("b", migraph::shape{migraph::shape::float_type, {5, 3}});
         auto at = p.add_instruction(migraph::op::transpose{{1, 0}}, a);
-        p.add_instruction(migraph::op::gemm{}, at, b);
+        p.add_instruction(migraph::op::dot{}, at, b);
         return p;
     }
 };
@@ -454,7 +540,7 @@ struct test_gemm_transposeab
         auto b  = p.add_parameter("b", migraph::shape{migraph::shape::float_type, {3, 5}});
         auto at = p.add_instruction(migraph::op::transpose{{1, 0}}, a);
         auto bt = p.add_instruction(migraph::op::transpose{{1, 0}}, b);
-        p.add_instruction(migraph::op::gemm{}, at, bt);
+        p.add_instruction(migraph::op::dot{}, at, bt);
         return p;
     }
 };
@@ -720,6 +806,9 @@ int main()
     verify_program<test_concat2>();
     verify_program<test_concat_relu>();
     verify_program<test_add>();
+    verify_program<test_add_half>();
+    verify_program<test_mul>();
+    verify_program<test_scale>();
     verify_program<test_triadd>();
     verify_program<test_triadd2>();
     verify_program<test_add_broadcast>();
@@ -733,9 +822,12 @@ int main()
     verify_program<test_conv>();
     verify_program<test_conv2>();
     verify_program<test_conv_relu>();
+    verify_program<test_conv_relu_half>();
     verify_program<test_add_relu>();
     verify_program<test_leaky_relu>();
     verify_program<test_conv_pooling>();
+    verify_program<test_global_avg_pooling>();
+    verify_program<test_global_max_pooling>();
     verify_program<test_gemm>();
     // verify_program<test_gemm_ld>();
     verify_program<test_gemm_transposeb>();

test/onnx/globalavgpool_test.onnx

+globalavgpool-example:i
+
+
0
1"GlobalAveragePooltest-globalavgpoolZ
+
0
+

+

+
+
+b
+
1
+

+

+
+

+
B
\ No newline at end of file

test/onnx/globalmaxpool_test.onnx

+globalmaxpool-example:e
+
+
0
1"
GlobalMaxPooltest-globalmaxpoolZ
+
0
+

+

+
+
+b
+
1
+

+

+
+

+
B
\ No newline at end of file

test/onnx/onnx_test.cpp

@@ -100,6 +100,52 @@ void leaky_relu_test()
     EXPECT(p == prog);
 }
 
+void imagescaler_test()
+{
+    migraph::program p;
+    migraph::shape s{migraph::shape::float_type, {1, 3, 16, 16}};
+    auto l0        = p.add_parameter("0", s);
+    auto scale_val = p.add_literal(0.5f);
+    auto bias_vals = p.add_literal(
+        migraph::literal{migraph::shape{migraph::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
+    auto scaled_tensor = p.add_instruction(migraph::op::scalar{s}, scale_val);
+    auto img_scaled    = p.add_instruction(migraph::op::mul{}, l0, scaled_tensor);
+    auto bias_bcast    = p.add_instruction(migraph::op::broadcast{1, s}, bias_vals);
+    p.add_instruction(migraph::op::add{}, img_scaled, bias_bcast);
+
+    auto prog = migraph::parse_onnx("imagescaler_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+void globalavgpool_test()
+{
+    migraph::program p;
+    auto input = p.add_parameter("0", migraph::shape{migraph::shape::float_type, {1, 3, 16, 16}});
+    auto op    = migraph::op::pooling{"average"};
+    auto lens  = input->get_shape().lens();
+    op.lengths = {lens[2], lens[3]};
+    p.add_instruction(op, input);
+
+    auto prog = migraph::parse_onnx("globalavgpool_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+void globalmaxpool_test()
+{
+    migraph::program p;
+    auto input = p.add_parameter("0", migraph::shape{migraph::shape::float_type, {1, 3, 16, 16}});
+    auto op    = migraph::op::pooling{"max"};
+    auto lens  = input->get_shape().lens();
+    op.lengths = {lens[2], lens[3]};
+    p.add_instruction(op, input);
+
+    auto prog = migraph::parse_onnx("globalmaxpool_test.onnx");
+
+    EXPECT(p == prog);
+}
+
 int main()
 {
     pytorch_conv_bias_test();
@@ -107,4 +153,7 @@ int main()
     pytorch_conv_bn_relu_maxpool();
     pytorch_conv_relu_maxpool_x2();
     leaky_relu_test();
+    imagescaler_test();
+    globalavgpool_test();
+    globalmaxpool_test();
 }

test/op_shape_test.cpp

@@ -93,7 +93,7 @@ void contiguous_shape()
     throws_shape(migraph::op::contiguous{}, input, input);
 
     migraph::shape single{migraph::shape::float_type, {2}};
-    throws_shape(migraph::op::contiguous{}, single);
+    expect_shape(single, migraph::op::contiguous{}, single);
 }
 
 void reshape_shape()