Merge from develop

src/targets/gpu/hip.cpp

 
-#include <migraph/gpu/hip.hpp>
+#include <migraphx/gpu/hip.hpp>
 
-#include <migraph/manage_ptr.hpp>
+#include <migraphx/manage_ptr.hpp>
 #include <miopen/miopen.h>
 
 #include <vector>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-using hip_ptr = MIGRAPH_MANAGE_PTR(void, hipFree);
+using hip_ptr = MIGRAPHX_MANAGE_PTR(void, hipFree);
 
 std::string hip_error(int error) { return hipGetErrorString(static_cast<hipError_t>(error)); }
 
 std::size_t get_available_gpu_memory()
 {
-    size_t free, total;
+    size_t free;
+    size_t total;
     auto status = hipMemGetInfo(&free, &total);
     if(status != hipSuccess)
-        MIGRAPH_THROW("Failed getting available memory: " + hip_error(status));
+        MIGRAPHX_THROW("Failed getting available memory: " + hip_error(status));
     return free;
 }
 
 hip_ptr allocate_gpu(std::size_t sz, bool host = false)
 {
     if(sz > get_available_gpu_memory())
-        MIGRAPH_THROW("Memory not available to allocate buffer: " + std::to_string(sz));
+        MIGRAPHX_THROW("Memory not available to allocate buffer: " + std::to_string(sz));
     void* result;
     auto status = host ? hipHostMalloc(&result, sz) : hipMalloc(&result, sz);
     if(status != hipSuccess)
     {
         if(host)
-            MIGRAPH_THROW("Gpu allocation failed: " + hip_error(status));
+            MIGRAPHX_THROW("Gpu allocation failed: " + hip_error(status));
         else
             allocate_gpu(sz, true);
     }
@@ -45,7 +46,7 @@ std::vector<T> read_from_gpu(const void* x, std::size_t sz)
     std::vector<T> result(sz);
     auto status = hipMemcpy(result.data(), x, sz * sizeof(T), hipMemcpyDeviceToHost);
     if(status != hipSuccess)
-        MIGRAPH_THROW("Copy from gpu failed: " + hip_error(status)); // NOLINT
+        MIGRAPHX_THROW("Copy from gpu failed: " + hip_error(status)); // NOLINT
     return result;
 }
 
@@ -54,7 +55,7 @@ hip_ptr write_to_gpu(const void* x, std::size_t sz, bool host = false)
     auto result = allocate_gpu(sz, host);
     auto status = hipMemcpy(result.get(), x, sz, hipMemcpyHostToDevice);
     if(status != hipSuccess)
-        MIGRAPH_THROW("Copy to gpu failed: " + hip_error(status));
+        MIGRAPHX_THROW("Copy to gpu failed: " + hip_error(status));
     return result;
 }
 
@@ -72,13 +73,13 @@ argument allocate_gpu(const shape& s, bool host)
     return {s, [p]() mutable { return reinterpret_cast<char*>(p.get()); }};
 }
 
-argument to_gpu(argument arg, bool host)
+argument to_gpu(const argument& arg, bool host)
 {
     auto p = share(write_to_gpu(arg.data(), arg.get_shape().bytes(), host));
     return {arg.get_shape(), [p]() mutable { return reinterpret_cast<char*>(p.get()); }};
 }
 
-argument from_gpu(argument arg)
+argument from_gpu(const argument& arg)
 {
     argument result;
     arg.visit([&](auto x) {
@@ -93,22 +94,22 @@ void set_device(std::size_t id)
 {
     auto status = hipSetDevice(id);
     if(status != hipSuccess)
-        MIGRAPH_THROW("Error setting device");
+        MIGRAPHX_THROW("Error setting device");
 }
 
 void gpu_sync() { hipDeviceSynchronize(); }
 
-void copy_to_gpu(argument src, argument dst)
+void copy_to_gpu(const argument& src, const argument& dst)
 {
     std::size_t src_size = src.get_shape().bytes();
     std::size_t dst_size = dst.get_shape().bytes();
     if(src_size > dst_size)
-        MIGRAPH_THROW("Not enough memory available in destination to do copy");
+        MIGRAPHX_THROW("Not enough memory available in destination to do copy");
     auto status = hipMemcpy(dst.data(), src.data(), src_size, hipMemcpyHostToDevice);
     if(status != hipSuccess)
-        MIGRAPH_THROW("Copy to gpu failed: " + hip_error(status));
+        MIGRAPHX_THROW("Copy to gpu failed: " + hip_error(status));
 }
 
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/targets/gpu/include/migraph/gpu/add.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_ADD_HPP
-#define MIGRAPH_GUARD_RTGLIB_ADD_HPP
-
-#include <migraph/gpu/lowering.hpp>
-#include <migraph/manage_ptr.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/generate.hpp>
-#include <migraph/shape_for_each.hpp>
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/dfor.hpp>
-#include <migraph/gpu/device/contiguous.hpp>
-#include <migraph/gpu/device/add.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/context.hpp>
-#include <migraph/config.hpp>
-#include <utility>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-namespace gpu {
-
-struct hip_add
-{
-    std::string name() const { return "gpu::add"; }
-    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; }
-};
-
-struct miopen_add
-{
-    std::string name() const { return "gpu::add"; }
-    shape compute_shape(const std::vector<shape>& inputs) const;
-    argument
-    compute(context& ctx, const shape& output_shape, const std::vector<argument>& args) const;
-    int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
-};
-
-} // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-
-#endif

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

-#ifndef MIGRAPH_GUARD_RTGLIB_MUL_HPP
-#define MIGRAPH_GUARD_RTGLIB_MUL_HPP
-
-#include <migraph/gpu/lowering.hpp>
-#include <migraph/manage_ptr.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/generate.hpp>
-#include <migraph/shape_for_each.hpp>
-#include <migraph/config.hpp>
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/dfor.hpp>
-#include <migraph/gpu/device/contiguous.hpp>
-#include <migraph/gpu/device/mul.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/context.hpp>
-#include <utility>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-namespace gpu {
-
-struct hip_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
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-
-#endif

src/targets/gpu/include/migraph/gpu/target.hpp

-#ifndef MIGRAPH_GUARD_MIGRAPHLIB_MIOPEN_TARGET_HPP
-#define MIGRAPH_GUARD_MIGRAPHLIB_MIOPEN_TARGET_HPP
-
-#include <migraph/program.hpp>
-#include <migraph/config.hpp>
-
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
-namespace gpu {
-
-struct target
-{
-    std::string name() const;
-    std::vector<pass> get_passes(migraph::context& gctx) const;
-    migraph::context get_context() const;
-};
-
-} // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
-
-#endif

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

+#ifndef MIGRAPHX_GUARD_RTGLIB_ABS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ABS_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/config.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/add.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace gpu {
+
+struct miopen_abs
+{
+    shared<activation_descriptor> ad;
+    std::string name() const { return "gpu::abs"; }
+    shape compute_shape(const std::vector<shape>& inputs) const;
+    argument
+    compute(context& ctx, const shape& output_shape, const std::vector<argument>& args) const;
+    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/acos.hpp

+#ifndef MIGRAPHX_GUARD_RTGLIB_ACOS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ACOS_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/acos.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 {
+
+struct hip_acos : unary_device<hip_acos, device::acos>
+{
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

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

+#ifndef MIGRAPHX_GUARD_RTGLIB_ADD_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ADD_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/add.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 {
+
+struct hip_add : binary_device<hip_add, device::add>
+{
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

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

+#ifndef MIGRAPHX_GUARD_RTGLIB_ASIN_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ASIN_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/asin.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 {
+
+struct hip_asin : unary_device<hip_asin, device::asin>
+{
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

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

+#ifndef MIGRAPHX_GUARD_RTGLIB_ATAN_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ATAN_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/atan.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 {
+
+struct hip_atan : unary_device<hip_atan, device::atan>
+{
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/targets/gpu/include/migraph/gpu/batchnorm.hpp → src/targets/gpu/include/migraphx/gpu/batchnorm.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_BATCHNORM_HPP
-#define MIGRAPH_GUARD_RTGLIB_BATCHNORM_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_BATCHNORM_HPP
+#define MIGRAPHX_GUARD_RTGLIB_BATCHNORM_HPP
 
-#include <migraph/gpu/lowering.hpp>
-#include <migraph/manage_ptr.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/generate.hpp>
-#include <migraph/shape_for_each.hpp>
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/dfor.hpp>
-#include <migraph/gpu/device/contiguous.hpp>
-#include <migraph/gpu/device/add.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/context.hpp>
-#include <migraph/config.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/add.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
+#include <migraphx/config.hpp>
 #include <utility>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
 struct miopen_batch_norm_inference
@@ -33,7 +33,7 @@ struct miopen_batch_norm_inference
 };
 
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/targets/gpu/include/migraph/gpu/concat.hpp → src/targets/gpu/include/migraphx/gpu/concat.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CONCAT_HPP
-#define MIGRAPH_GUARD_RTGLIB_CONCAT_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CONCAT_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CONCAT_HPP
 
-#include <migraph/gpu/lowering.hpp>
-#include <migraph/manage_ptr.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/generate.hpp>
-#include <migraph/shape_for_each.hpp>
-#include <migraph/config.hpp>
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/dfor.hpp>
-#include <migraph/gpu/device/concat.hpp>
-#include <migraph/gpu/device/add.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/context.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/config.hpp>
+#include <migraphx/gpu/miopen.hpp>
+#include <migraphx/gpu/hip.hpp>
+#include <migraphx/dfor.hpp>
+#include <migraphx/gpu/device/concat.hpp>
+#include <migraphx/gpu/device/add.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
 #include <utility>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
 struct hip_concat
@@ -34,7 +34,7 @@ struct hip_concat
 };
 
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/targets/gpu/include/migraph/gpu/concat_gpu_opt.hpp → src/targets/gpu/include/migraphx/gpu/concat_gpu_opt.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CONCAT_GPU_OPT_HPP
-#define MIGRAPH_GUARD_RTGLIB_CONCAT_GPU_OPT_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CONCAT_GPU_OPT_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CONCAT_GPU_OPT_HPP
 
-#include <migraph/gpu/concat.hpp>
+#include <migraphx/gpu/concat.hpp>
 
-namespace migraph {
+namespace migraphx {
 namespace gpu {
 
 struct concat_gpu_optimization
 {
     std::string name() const { return "gpu::concat"; }
     std::string allocate() const { return "hip::allocate"; }
-    migraph::op::concat get_concat(const migraph::operation& op) const
+    migraphx::op::concat get_concat(const migraphx::operation& op) const
     {
-        return migraph::any_cast<migraph::gpu::hip_concat>(op).op;
+        return migraphx::any_cast<migraphx::gpu::hip_concat>(op).op;
     }
 };
 
 } // namespace gpu
 
-} // namespace migraph
+} // namespace migraphx
 
 #endif

src/targets/gpu/include/migraph/gpu/context.hpp → src/targets/gpu/include/migraphx/gpu/context.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CONTEXT_HPP
-#define MIGRAPH_GUARD_RTGLIB_CONTEXT_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CONTEXT_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CONTEXT_HPP
 
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/env.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/gpu/miopen.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/hip.hpp>
+#include <migraphx/env.hpp>
+#include <migraphx/config.hpp>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-MIGRAPH_DECLARE_ENV_VAR(MIGRAPH_DISABLE_NULL_STREAM)
+MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_DISABLE_NULL_STREAM)
 
 struct hip_device
 {
@@ -21,7 +21,7 @@ struct hip_device
 
     struct stream
     {
-        using hip_stream_ptr = MIGRAPH_MANAGE_PTR(hipStream_t, hipStreamDestroy);
+        using hip_stream_ptr = MIGRAPHX_MANAGE_PTR(hipStream_t, hipStreamDestroy);
 
         stream() {}
 
@@ -34,13 +34,13 @@ struct hip_device
             hipStream_t result = nullptr;
             auto status        = hipStreamCreate(&result);
             if(status != hipSuccess)
-                MIGRAPH_THROW("Failed to allocate stream");
+                MIGRAPHX_THROW("Failed to allocate stream");
             return hip_stream_ptr{result};
         }
 
         hipStream_t get()
         {
-            if(enabled(MIGRAPH_DISABLE_NULL_STREAM{}))
+            if(enabled(MIGRAPHX_DISABLE_NULL_STREAM{}))
             {
                 setup();
                 if(s == nullptr)
@@ -53,7 +53,7 @@ struct hip_device
 
         auto create_miopen_handle()
         {
-            if(enabled(MIGRAPH_DISABLE_NULL_STREAM{}))
+            if(enabled(MIGRAPHX_DISABLE_NULL_STREAM{}))
                 return make_obj<miopen_handle>(&miopenCreateWithStream, get());
             else
                 return make_obj<miopen_handle>(&miopenCreate);
@@ -116,7 +116,7 @@ struct context
     std::shared_ptr<hip_device> current_device;
 };
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/targets/gpu/include/migraph/gpu/contiguous.hpp → src/targets/gpu/include/migraphx/gpu/contiguous.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CONTIGUOUS_HPP
-#define MIGRAPH_GUARD_RTGLIB_CONTIGUOUS_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CONTIGUOUS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CONTIGUOUS_HPP
 
-#include <migraph/gpu/lowering.hpp>
-#include <migraph/manage_ptr.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/generate.hpp>
-#include <migraph/shape_for_each.hpp>
-#include <migraph/config.hpp>
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/dfor.hpp>
-#include <migraph/gpu/device/contiguous.hpp>
-#include <migraph/gpu/device/add.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/context.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/config.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/add.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
 #include <utility>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
 struct miopen_contiguous
@@ -32,7 +32,7 @@ struct miopen_contiguous
 };
 
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/targets/gpu/include/migraph/gpu/convolution.hpp → src/targets/gpu/include/migraphx/gpu/convolution.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CONVOLUTION_HPP
-#define MIGRAPH_GUARD_RTGLIB_CONVOLUTION_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CONVOLUTION_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CONVOLUTION_HPP
 
-#include <migraph/gpu/lowering.hpp>
-#include <migraph/manage_ptr.hpp>
-#include <migraph/instruction.hpp>
-#include <migraph/operators.hpp>
-#include <migraph/generate.hpp>
-#include <migraph/shape_for_each.hpp>
-#include <migraph/config.hpp>
-#include <migraph/gpu/miopen.hpp>
-#include <migraph/gpu/hip.hpp>
-#include <migraph/dfor.hpp>
-#include <migraph/gpu/device/contiguous.hpp>
-#include <migraph/gpu/device/add.hpp>
-#include <migraph/iterator_for.hpp>
-#include <migraph/gpu/rocblas.hpp>
-#include <migraph/gpu/context.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/config.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/add.hpp>
+#include <migraphx/iterator_for.hpp>
+#include <migraphx/gpu/rocblas.hpp>
+#include <migraphx/gpu/context.hpp>
 #include <utility>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
 struct miopen_convolution
@@ -27,6 +27,7 @@ struct miopen_convolution
     op::convolution op;
     shared<convolution_descriptor> cd;
     miopenConvFwdAlgorithm_t algo{};
+    miopenHandle_t handle = nullptr;
 
     template <class Self, class F>
     static auto reflect(Self& self, F f)
@@ -39,12 +40,13 @@ struct miopen_convolution
     shape compute_shape(const std::vector<shape>& inputs) const;
     argument
     compute(context& ctx, const shape& output_shape, const std::vector<argument>& args) const;
-    shape compile(context& ctx, const shape& output_shape, std::vector<instruction_ref> inputs);
+    shape compile(context& ctx, const shape& output_shape, std::vector<shape> inputs);
+    void finalize(context& ctx, const shape& output_shape, std::vector<shape> inputs);
     int output_alias(const std::vector<shape>& shapes) const { return shapes.size() - 1; }
 };
 
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

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

+#ifndef MIGRAPHX_GUARD_RTGLIB_COS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_COS_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/cos.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 {
+
+struct hip_cos : unary_device<hip_cos, device::cos>
+{
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

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

+#ifndef MIGRAPHX_GUARD_RTGLIB_COSH_HPP
+#define MIGRAPHX_GUARD_RTGLIB_COSH_HPP
+
+#include <migraphx/gpu/lowering.hpp>
+#include <migraphx/gpu/oper.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/gpu/device/contiguous.hpp>
+#include <migraphx/gpu/device/cosh.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 {
+
+struct hip_cosh : unary_device<hip_cosh, device::cosh>
+{
+};
+
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/targets/gpu/include/migraphx/gpu/device/acos.hpp

+#ifndef MIGRAPHX_GUARD_RTGLIB_DEVICE_ACOS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_DEVICE_ACOS_HPP
+
+#include <migraphx/argument.hpp>
+#include <migraphx/config.hpp>
+#include <hip/hip_runtime_api.h>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace gpu {
+namespace device {
+
+void acos(hipStream_t stream, const argument& result, const argument& arg);
+
+} // namespace device
+} // namespace gpu
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/targets/gpu/include/migraph/gpu/device/add.hpp → src/targets/gpu/include/migraphx/gpu/device/add.hpp

 
-#ifndef MIGRAPH_GUARD_RTGLIB_DEVICE_ADD_HPP
-#define MIGRAPH_GUARD_RTGLIB_DEVICE_ADD_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_DEVICE_ADD_HPP
+#define MIGRAPHX_GUARD_RTGLIB_DEVICE_ADD_HPP
 
-#include <migraph/argument.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/argument.hpp>
+#include <migraphx/config.hpp>
 #include <hip/hip_runtime_api.h>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 namespace device {
 
@@ -21,7 +21,7 @@ void add(hipStream_t stream,
 
 } // namespace device
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif

src/targets/gpu/include/migraph/gpu/device/add_relu.hpp → src/targets/gpu/include/migraphx/gpu/device/add_relu.hpp

 
-#ifndef MIGRAPH_GUARD_RTGLIB_DEVICE_ADD_RELU_HPP
-#define MIGRAPH_GUARD_RTGLIB_DEVICE_ADD_RELU_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_DEVICE_ADD_RELU_HPP
+#define MIGRAPHX_GUARD_RTGLIB_DEVICE_ADD_RELU_HPP
 
-#include <migraph/argument.hpp>
-#include <migraph/config.hpp>
+#include <migraphx/argument.hpp>
+#include <migraphx/config.hpp>
 #include <hip/hip_runtime_api.h>
 
-namespace migraph {
-inline namespace MIGRAPH_INLINE_NS {
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 namespace device {
 
@@ -24,7 +24,7 @@ void add_relu(hipStream_t stream,
 
 } // namespace device
 } // namespace gpu
-} // namespace MIGRAPH_INLINE_NS
-} // namespace migraph
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 #endif