manual merge

src/targets/gpu/cos.cpp → src/targets/gpu/include/migraphx/gpu/log.hpp

-#include <migraphx/gpu/cos.hpp>
-#include <migraphx/operators.hpp>
+#ifndef MIGRAPHX_GUARD_RTGLIB_LOG_HPP
+#define MIGRAPHX_GUARD_RTGLIB_LOG_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
-#include <migraphx/config.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/shape_for_each.hpp>
 #include <migraphx/gpu/miopen.hpp>
+#include <migraphx/gpu/hip.hpp>
+#include <migraphx/dfor.hpp>
+#include <migraphx/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/log.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
+#include <migraphx/config.hpp>
 #include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-shape hip_cos::compute_shape(const std::vector<shape>& inputs) const
-{
-    check_shapes{inputs, *this}.has(2);
-    return inputs.at(0);
-}
-
-argument hip_cos::compute(context& ctx, const shape&, const std::vector<argument>& args) const
+struct hip_log : unary_device<hip_log, device::log>
 {
-    device::cos(ctx.get_stream().get(), args[1], args[0]);
-    return args[1];
-}
+};
 
 } // namespace gpu
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
+
+#endif

src/targets/gpu/include/migraphx/gpu/max.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_MAX_HPP
 
 #include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
 #include <migraphx/instruction.hpp>
 #include <migraphx/operators.hpp>
@@ -22,12 +23,8 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-struct hip_max
+struct hip_max : binary_device<hip_max, device::max>
 {
-    std::string name() const { return "gpu::max"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument compute(context&, const shape&, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu

src/targets/gpu/include/migraphx/gpu/min.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_MIN_HPP
 
 #include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
 #include <migraphx/instruction.hpp>
 #include <migraphx/operators.hpp>
@@ -22,12 +23,8 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-struct hip_min
+struct hip_min : binary_device<hip_min, device::min>
 {
-    std::string name() const { return "gpu::min"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument compute(context&, const shape&, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu

src/targets/gpu/include/migraphx/gpu/mul.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_MUL_HPP
 
 #include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
 #include <migraphx/instruction.hpp>
 #include <migraphx/operators.hpp>
@@ -22,12 +23,8 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-struct hip_mul
+struct hip_mul : binary_device<hip_mul, device::mul>
 {
-    std::string name() const { return "gpu::mul"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument compute(context&, const shape&, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu

src/targets/gpu/include/migraphx/gpu/oper.hpp

+#ifndef MIGRAPHX_GUARD_RTGLIB_UNARY_HPP
+#define MIGRAPHX_GUARD_RTGLIB_UNARY_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/manage_ptr.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/gpu/miopen.hpp>
+#include <migraphx/gpu/hip.hpp>
+#include <migraphx/dfor.hpp>
+#include <migraphx/type_name.hpp>
+#include <migraphx/gpu/device/contiguous.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
+#include <migraphx/config.hpp>
+#include <utility>
+#include <iostream>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace gpu {
+
+template <class Derived>
+struct oper
+{
+    std::string name() const
+    {
+        const std::string& name = get_type_name<Derived>();
+        // search the namespace gpu (::gpu::)
+        auto pos_ns = name.find("::gpu::");
+        if(pos_ns != std::string::npos)
+        {
+            auto pos_name = name.find("hip_", pos_ns + std::string("::gpu::").length());
+            if(pos_name != std::string::npos)
+            {
+                return std::string("gpu::") + name.substr(pos_name + 4);
+            }
+            else
+            {
+                return name.substr(pos_ns + 2);
+            }
+        }
+
+        return "unknown";
+    }
+};
+
+template <class Derived, void (*F)(hipStream_t, const argument&, const argument&)>
+struct unary_device : oper<Derived>
+{
+    shape compute_shape(const std::vector<shape>& inputs) const
+    {
+        check_shapes{inputs, *this}.has(2);
+        return inputs.at(0);
+    }
+
+    argument compute(context& ctx, const shape&, const std::vector<argument>& args) const
+    {
+        F(ctx.get_stream().get(), args[1], args[0]);
+        return args[1];
+    }
+
+    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
+};
+
+template <class Derived, void (*F)(hipStream_t, const argument&, const argument&, const argument&)>
+struct binary_device : oper<Derived>
+{
+    shape compute_shape(const std::vector<shape>& inputs) const
+    {
+        check_shapes{inputs, *this}.has(3);
+        return inputs.at(0);
+    }
+
+    argument compute(context& ctx, const shape&, const std::vector<argument>& args) const
+    {
+        F(ctx.get_stream().get(), args[2], args[1], args[0]);
+        return args[2];
+    }
+
+    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/targets/gpu/include/migraphx/gpu/sin.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_SIN_HPP
 
 #include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
 #include <migraphx/instruction.hpp>
 #include <migraphx/operators.hpp>
@@ -22,12 +23,8 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-struct hip_sin
+struct hip_sin : unary_device<hip_sin, device::sin>
 {
-    std::string name() const { return "gpu::sin"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument compute(context&, const shape&, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu

src/targets/gpu/include/migraphx/gpu/sinh.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_SINH_HPP
 
 #include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
 #include <migraphx/instruction.hpp>
 #include <migraphx/operators.hpp>
@@ -22,12 +23,8 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-struct hip_sinh
+struct hip_sinh : unary_device<hip_sinh, device::sinh>
 {
-    std::string name() const { return "gpu::sinh"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument compute(context&, const shape&, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu

src/targets/gpu/include/migraphx/gpu/tan.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_TAN_HPP
 
 #include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.hpp>
 #include <migraphx/manage_ptr.hpp>
 #include <migraphx/instruction.hpp>
 #include <migraphx/operators.hpp>
@@ -11,8 +12,6 @@
 #include <migraphx/gpu/hip.hpp>
 #include <migraphx/dfor.hpp>
 #include <migraphx/gpu/device/contiguous.hpp>
-#include <migraphx/gpu/device/sin.hpp>
-#include <migraphx/gpu/device/cos.hpp>
 #include <migraphx/gpu/device/tan.hpp>
 #include <migraphx/iterator_for.hpp>
 #include <migraphx/gpu/rocblas.hpp>
@@ -24,12 +23,8 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-struct hip_tan
+struct hip_tan : unary_device<hip_tan, device::tan>
 {
-    std::string name() const { return "gpu::tan"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument compute(context&, const shape&, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu

src/targets/gpu/lowering.cpp

@@ -22,6 +22,8 @@
 #include <migraphx/gpu/elu.hpp>
 #include <migraphx/gpu/softmax.hpp>
 #include <migraphx/gpu/add.hpp>
+#include <migraphx/gpu/exp.hpp>
+#include <migraphx/gpu/log.hpp>
 #include <migraphx/gpu/sin.hpp>
 #include <migraphx/gpu/cos.hpp>
 #include <migraphx/gpu/tan.hpp>
@@ -69,6 +71,8 @@ struct miopen_apply
         add_miopen_extend_op<miopen_elu, op::elu>("elu", make_elu);
 
         add_generic_op<hip_add>("add");
+        add_generic_op<hip_exp>("exp");
+        add_generic_op<hip_log>("log");
         add_generic_op<hip_sin>("sin");
         add_generic_op<hip_cos>("cos");
         add_generic_op<hip_tan>("tan");

src/targets/gpu/max.cpp

-#include <migraphx/gpu/max.hpp>
-#include <migraphx/operators.hpp>
-#include <migraphx/manage_ptr.hpp>
-#include <migraphx/gpu/miopen.hpp>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace gpu {
-
-shape hip_max::compute_shape(const std::vector<shape>& inputs) const
-{
-    // check_shapes{inputs, *this}.has(3).standard();
-    check_shapes{inputs, *this}.has(3);
-    return inputs.at(0);
-}
-
-argument hip_max::compute(context& ctx, const shape&, const std::vector<argument>& args) const
-{
-    device::max(ctx.get_stream().get(), args[2], args[0], args[1]);
-    return args[2];
-}
-
-} // namespace gpu
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx

src/targets/gpu/min.cpp

-#include <migraphx/gpu/min.hpp>
-#include <migraphx/operators.hpp>
-#include <migraphx/manage_ptr.hpp>
-#include <migraphx/gpu/miopen.hpp>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace gpu {
-
-shape hip_min::compute_shape(const std::vector<shape>& inputs) const
-{
-    // check_shapes{inputs, *this}.has(3).standard();
-    check_shapes{inputs, *this}.has(3);
-    return inputs.at(0);
-}
-
-argument hip_min::compute(context& ctx, const shape&, const std::vector<argument>& args) const
-{
-    device::min(ctx.get_stream().get(), args[2], args[0], args[1]);
-    return args[2];
-}
-
-} // namespace gpu
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx

src/targets/gpu/mul.cpp

-#include <migraphx/gpu/mul.hpp>
-#include <migraphx/operators.hpp>
-#include <migraphx/manage_ptr.hpp>
-#include <migraphx/gpu/miopen.hpp>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace gpu {
-
-shape hip_mul::compute_shape(const std::vector<shape>& inputs) const
-{
-    // check_shapes{inputs, *this}.has(3).standard();
-    check_shapes{inputs, *this}.has(3);
-    return inputs.at(0);
-}
-
-argument hip_mul::compute(context& ctx, const shape&, const std::vector<argument>& args) const
-{
-    device::mul(ctx.get_stream().get(), args[2], args[0], args[1]);
-    return args[2];
-}
-
-} // namespace gpu
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx

src/targets/gpu/sin.cpp

-#include <migraphx/gpu/sin.hpp>
-#include <migraphx/operators.hpp>
-#include <migraphx/manage_ptr.hpp>
-#include <migraphx/config.hpp>
-#include <migraphx/gpu/miopen.hpp>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace gpu {
-
-shape hip_sin::compute_shape(const std::vector<shape>& inputs) const
-{
-    check_shapes{inputs, *this}.has(2);
-    return inputs.at(0);
-}
-
-argument hip_sin::compute(context& ctx, const shape&, const std::vector<argument>& args) const
-{
-    device::sin(ctx.get_stream().get(), args[1], args[0]);
-    return args[1];
-}
-
-} // namespace gpu
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx

src/targets/gpu/sinh.cpp

-#include <migraphx/gpu/sinh.hpp>
-#include <migraphx/operators.hpp>
-#include <migraphx/manage_ptr.hpp>
-#include <migraphx/config.hpp>
-#include <migraphx/gpu/miopen.hpp>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace gpu {
-
-shape hip_sinh::compute_shape(const std::vector<shape>& inputs) const
-{
-    check_shapes{inputs, *this}.has(2);
-    return inputs.at(0);
-}
-
-argument hip_sinh::compute(context& ctx, const shape&, const std::vector<argument>& args) const
-{
-    device::sinh(ctx.get_stream().get(), args[1], args[0]);
-    return args[1];
-}
-
-} // namespace gpu
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx

src/targets/gpu/tan.cpp

-#include <migraphx/gpu/tan.hpp>
-#include <migraphx/operators.hpp>
-#include <migraphx/manage_ptr.hpp>
-#include <migraphx/config.hpp>
-#include <migraphx/gpu/miopen.hpp>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace gpu {
-
-shape hip_tan::compute_shape(const std::vector<shape>& inputs) const
-{
-    check_shapes{inputs, *this}.has(2);
-    return inputs.at(0);
-}
-
-argument hip_tan::compute(context& ctx, const shape&, const std::vector<argument>& args) const
-{
-    device::tan(ctx.get_stream().get(), args[1], args[0]);
-    return args[1];
-}
-
-} // namespace gpu
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx

test/cpu_ops_test.cpp

@@ -413,6 +413,20 @@ TEST_CASE(exp_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
+TEST_CASE(log_test)
+{
+    migraphx::program p;
+    migraphx::shape s{migraphx::shape::float_type, {3}};
+    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({});
+    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};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
 TEST_CASE(sin_test)
 {
     migraphx::program p;

test/gpu/miopen.cpp

@@ -203,6 +203,32 @@ struct test_mul
     }
 };
 
+struct test_exp
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        migraphx::shape s{migraphx::shape::float_type, {6}};
+        std::vector<float> data{0.1f, 0.2f, 1.f, 2.f, 0.6f, 10.f};
+        auto x = p.add_literal(s, data);
+        p.add_instruction(migraphx::op::exp{}, x);
+        return p;
+    }
+};
+
+struct test_log
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        migraphx::shape s{migraphx::shape::float_type, {6}};
+        std::vector<float> data{0.1f, 0.2f, 1.f, 2.f, 0.6f, 100.f};
+        auto x = p.add_literal(s, data);
+        p.add_instruction(migraphx::op::log{}, x);
+        return p;
+    }
+};
+
 struct test_sin
 {
     migraphx::program create_program() const
@@ -984,6 +1010,8 @@ int main()
     verify_program<test_add>();
     verify_program<test_add_half>();
     verify_program<test_mul>();
+    verify_program<test_exp>();
+    verify_program<test_log>();
     verify_program<test_sin>();
     verify_program<test_cos>();
     verify_program<test_tan>();

test/onnx/exp_test.onnx

+exp-example:9
+
+
x
y"Exptest_expZ
+
x
+
+

+
+b
+
y
+
+

+
+B	
\ No newline at end of file

test/onnx/log_test.onnx

+log-example:9
+
+
x
y"Logtest_logZ
+
x
+
+

+
+b
+
y
+
+

+
+B	
\ No newline at end of file

test/onnx/onnx_test.cpp

@@ -179,6 +179,27 @@ TEST_CASE(sum_test)
     p.add_instruction(migraphx::op::add{}, l0, input2);
 
     auto prog = migraphx::parse_onnx("sum_test.onnx");
+    EXPECT(p == prog);
+}
+
+void exp_test()
+{
+    migraphx::program p;
+    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
+    p.add_instruction(migraphx::op::exp{}, input);
+
+    auto prog = migraphx::parse_onnx("exp_test.onnx");
+    EXPECT(p == prog);
+}
+
+void log_test()
+{
+    migraphx::program p;
+    auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
+    p.add_instruction(migraphx::op::log{}, input);
+
+    auto prog = migraphx::parse_onnx("log_test.onnx");
+    EXPECT(p == prog);
 }
 
 TEST_CASE(sin_test)
@@ -301,6 +322,7 @@ TEST_CASE(atan_test)
     EXPECT(p == prog);
 }
 
+<<<<<<< HEAD
 TEST_CASE(add_bcast_test)
 {
     migraphx::program p;
@@ -312,6 +334,34 @@ TEST_CASE(add_bcast_test)
     auto prog = migraphx::parse_onnx("add_bcast_test.onnx");
 
     EXPECT(p == prog);
+=======
+int main()
+{
+    pytorch_conv_bias_test();
+    pytorch_conv_relu_maxpool();
+    pytorch_conv_bn_relu_maxpool();
+    pytorch_conv_relu_maxpool_x2();
+    leaky_relu_test();
+    imagescaler_test();
+    globalavgpool_test();
+    globalmaxpool_test();
+    transpose_test();
+    dropout_test();
+    sum_test();
+    max_test();
+    min_test();
+    exp_test();
+    log_test();
+    sin_test();
+    cos_test();
+    tan_test();
+    sinh_test();
+    cosh_test();
+    tanh_test();
+    asin_test();
+    acos_test();
+    atan_test();
+>>>>>>> 436b459e73e8a18e3f08ac6863c25279ca811fd9
 }
 
 TEST_CASE(implicit_bcast_test)