Merge branch 'develop' into doc2

CMakeLists.txt

@@ -22,7 +22,7 @@ find_package(ROCM REQUIRED)
 
 include(ROCMSetupVersion)
 
-rocm_setup_version(VERSION 0.5)
+rocm_setup_version(VERSION 0.6)
 set(MIGRAPHX_SO_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR})
 
 option( BUILD_SHARED_LIBS "Build as a shared library" ON )
@@ -69,13 +69,26 @@ rocm_enable_clang_tidy(
         modernize-*
         performance-*
         readability-*
-        -clang-analyzer-alpha.core.CastToStruct
+        # Disable all alpha checks by default
+        -clang-analyzer-alpha*
+        # Enable some alpha checks
+        clang-analyzer-alpha.core.CallAndMessageUnInitRefArg
+        clang-analyzer-alpha.core.Conversion
+        clang-analyzer-alpha.core.IdenticalExpr
+        clang-analyzer-alpha.core.PointerArithm
+        clang-analyzer-alpha.core.PointerSub
+        clang-analyzer-alpha.core.TestAfterDivZero
+        clang-analyzer-alpha.cplusplus.InvalidIterator
+        clang-analyzer-alpha.cplusplus.IteratorRange
+        clang-analyzer-alpha.cplusplus.MismatchedIterator
+        clang-analyzer-alpha.cplusplus.MisusedMovedObject
         -clang-analyzer-optin.performance.Padding
         -clang-diagnostic-deprecated-declarations
         -clang-diagnostic-extern-c-compat
         -clang-diagnostic-disabled-macro-expansion
         -clang-diagnostic-unused-command-line-argument
         -cppcoreguidelines-explicit-virtual-functions
+        -cppcoreguidelines-init-variables
         -cppcoreguidelines-pro-bounds-array-to-pointer-decay
         -cppcoreguidelines-pro-bounds-constant-array-index
         -cppcoreguidelines-pro-bounds-pointer-arithmetic
@@ -97,6 +110,7 @@ rocm_enable_clang_tidy(
         -modernize-use-transparent-functors
         -performance-type-promotion-in-math-fn
         -readability-braces-around-statements
+        -readability-convert-member-functions-to-static
         -readability-else-after-return
         -readability-named-parameter
         -readability-uppercase-literal-suffix,
@@ -114,12 +128,14 @@ rocm_enable_clang_tidy(
         -UNDEBUG
         -DMIGRAPHX_USE_CLANG_TIDY
         "-Dmain\\\\(...\\\\)=main\\\\(__VA_ARGS__\\\\) // NOLINT"
-    # CLANG_ARGS
-    #     -analyzer-config optin.cplusplus.UninitializedObject:Pedantic=true
-    #     -analyzer-config widen-loops=true
-    #     -analyzer-config unroll-loops=true
-    #     -analyzer-config cfg-lifetime=true
-    #     -analyzer-config cfg-scopes=true
+    CLANG_ARGS
+        -analyzer-max-loop 10
+        -analyzer-inline-max-stack-depth 10
+        -analyzer-config optin.cplusplus.UninitializedObject:Pedantic=true
+        -analyzer-config widen-loops=true
+        -analyzer-config unroll-loops=true
+        -analyzer-config cfg-lifetime=true
+        -analyzer-config cfg-scopes=true
 )
 include(ROCMCppCheck)
 rocm_enable_cppcheck(
@@ -169,7 +185,7 @@ rocm_create_package(
     MAINTAINER "Paul Fultz II <paul.fultz@amd.com>"
     LDCONFIG
     PTH
-    DEPENDS miopen-hip rocblas hip_hcc half
+    DEPENDS miopen-hip rocblas hip-hcc half
 )
 
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)

Dockerfile

@@ -35,8 +35,11 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --allow-
     libpthread-stubs0-dev \
     libssl-dev \
     python \
+    python3 \
     python-dev \
+    python3-dev \
     python-pip \
+    python3-pip \
     rocm-device-libs \
     rocm-opencl \
     rocm-opencl-dev \
@@ -53,7 +56,7 @@ RUN pip install cget
 RUN pip install https://github.com/pfultz2/rclone/archive/master.tar.gz
 
 # Install yapf
-RUN pip install yapf==0.28.0
+RUN pip3 install yapf==0.28.0
 
 # Install hcc
 RUN rclone -b roc-2.6.x -c 0f4c96b7851af2663a7f3ac16ecfb76c7c78a5bf https://github.com/RadeonOpenCompute/hcc.git /hcc

Jenkinsfile

@@ -9,7 +9,7 @@ def rocmtestnode(variant, name, body) {
             mkdir build
             cd build
             CXX=${compiler} CXXFLAGS='-Werror -Wno-fallback' cmake ${flags} .. 
-            CTEST_PARALLEL_LEVEL=32 make -j32 generate all doc package check
+            CTEST_PARALLEL_LEVEL=32 make -j\$(nproc) generate all doc package check
         """
         echo cmd
         sh cmd
@@ -82,7 +82,7 @@ rocmtest tidy: rocmnode('rocmtest') { cmake_build ->
             mkdir build
             cd build
             CXX=hcc cmake .. 
-            make -j8 -k analyze
+            make -j$(nproc) -k analyze
         '''
     }
 }, format: rocmnode('rocmtest') { cmake_build ->

doc/src/reference/program.rst

@@ -27,3 +27,13 @@ parse_tf
 --------
 
 .. doxygenfunction:: migraphx::MIGRAPHX_INLINE_NS::parse_tf
+
+onnx_options
+------------
+
+.. doxygenstruct:: migraphx::onnx_options
+
+tf_options
+----------
+
+.. doxygenstruct:: migraphx::tf_options

doc/src/reference/py.rst

@@ -192,23 +192,25 @@ program
 parse_onnx
 ----------
 
-.. py:function:: parse_onnx(filename)
+.. py:function:: parse_onnx(filename, batch_size=1)
 
     Load and parse an onnx file.
 
     :param str filename: Path to file.
+    :param str batch_size: default batch size to use (if not specified in onnx file).
 
     :rtype: program
 
 parse_tf
 ----------
 
-.. py:function:: parse_tf(filename, is_nhwc=True)
+.. py:function:: parse_tf(filename, is_nhwc=True, batch_size=1)
 
     Load and parse an tensorflow protobuf file file.
 
     :param str filename: Path to file.
     :param bool is_nhwc: Use nhwc as default format.
+    :param str batch_size: default batch size to use (if not specified in protobuf).
 
     :rtype: program
 

requirements.txt

-google/protobuf@v3.8.0 -DCMAKE_POSITION_INDEPENDENT_CODE=On -X subdir -Dprotobuf_BUILD_TESTS=Off
+google/protobuf@v3.11.0 -DCMAKE_POSITION_INDEPENDENT_CODE=On -X subdir -Dprotobuf_BUILD_TESTS=Off
 RadeonOpenCompute/rocm-cmake@b29ff83 --build
 ROCmSoftwarePlatform/rocBLAS@7197df74e5a1ba64ff967065872e5f86a3516637
 ROCmSoftwarePlatform/MIOpen@2.0.0

src/CMakeLists.txt

@@ -42,6 +42,7 @@ target_include_directories(migraphx SYSTEM PUBLIC $<BUILD_INTERFACE:${HALF_INCLU
 
 set(PACKAGE_DEPENDS)
 
+add_subdirectory(api)
 add_subdirectory(driver)
 add_subdirectory(onnx)
 add_subdirectory(tf)
@@ -49,7 +50,7 @@ add_subdirectory(tf)
 add_subdirectory(py)
 add_subdirectory(targets/cpu)
 if(MIGRAPHX_ENABLE_GPU)
-list(APPEND PACKAGE_DEPENDS MIOpen rocblas)
+list(APPEND PACKAGE_DEPENDS PACKAGE MIOpen PACKAGE rocblas)
 add_subdirectory(targets/gpu)
 endif()
 

src/api/CMakeLists.txt

+
+add_library(migraphx_c
+    api.cpp
+)
+set_target_properties(migraphx_c PROPERTIES EXPORT_NAME c)
+rocm_set_soversion(migraphx_c 1.0)
+
+rocm_clang_tidy_check(migraphx_c)
+target_link_libraries(migraphx_c PRIVATE migraphx migraphx_tf migraphx_onnx migraphx_cpu)
+if(MIGRAPHX_ENABLE_GPU)
+    target_link_libraries(migraphx_c PRIVATE migraphx_gpu)
+    target_compile_definitions(migraphx_c PRIVATE -DHAVE_GPU)
+endif()
+
+rocm_install_targets(
+  TARGETS migraphx_c
+  INCLUDE
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)

src/api/include/migraphx/migraphx.h

+#ifndef MIGRAPHX_GUARD_C_API_MIGRAPHX_H
+#define MIGRAPHX_GUARD_C_API_MIGRAPHX_H
+
+#include <stdlib.h>
+
+// Add new types here
+// clang-format off
+#define MIGRAPHX_SHAPE_VISIT_TYPES(m) \
+    m(half_type, half) \
+    m(float_type, float) \
+    m(double_type, double) \
+    m(uint8_type, uint8_t) \
+    m(int8_type, int8_t) \
+    m(uint16_type, uint16_t) \
+    m(int16_type, int16_t) \
+    m(int32_type, int32_t) \
+    m(int64_type, int64_t) \
+    m(uint32_type, uint32_t) \
+    m(uint64_type, uint64_t)
+// clang-format on
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// return code, more to be added later
+typedef enum {
+    migraphx_status_success        = 0,
+    migraphx_status_bad_param      = 1,
+    migraphx_status_unknown_target = 3,
+    migraphx_status_unknown_error  = 4,
+
+} migraphx_status;
+
+#define MIGRAPHX_SHAPE_GENERATE_ENUM_TYPES(x, t) migraphx_shape_##x,
+typedef enum {
+    MIGRAPHX_SHAPE_VISIT_TYPES(MIGRAPHX_SHAPE_GENERATE_ENUM_TYPES)
+} migraphx_shape_datatype_t;
+#undef MIGRAPHX_SHAPE_GENERATE_ENUM_TYPES
+
+typedef struct
+{
+    bool offload_copy;
+} migraphx_compile_options;
+
+typedef struct
+{
+    size_t batch_size;
+} migraphx_onnx_options;
+
+typedef struct migraphx_shape* migraphx_shape_t;
+typedef const struct migraphx_shape* const_migraphx_shape_t;
+
+typedef struct migraphx_argument* migraphx_argument_t;
+typedef const struct migraphx_argument* const_migraphx_argument_t;
+
+typedef struct migraphx_target* migraphx_target_t;
+typedef const struct migraphx_target* const_migraphx_target_t;
+
+typedef struct migraphx_program_parameter_shapes* migraphx_program_parameter_shapes_t;
+typedef const struct migraphx_program_parameter_shapes* const_migraphx_program_parameter_shapes_t;
+
+typedef struct migraphx_program_parameters* migraphx_program_parameters_t;
+typedef const struct migraphx_program_parameters* const_migraphx_program_parameters_t;
+
+typedef struct migraphx_arguments* migraphx_arguments_t;
+typedef const struct migraphx_arguments* const_migraphx_arguments_t;
+
+typedef struct migraphx_shapes* migraphx_shapes_t;
+typedef const struct migraphx_shapes* const_migraphx_shapes_t;
+
+typedef struct migraphx_program* migraphx_program_t;
+typedef const struct migraphx_program* const_migraphx_program_t;
+
+migraphx_status migraphx_shape_destroy(migraphx_shape_t shape);
+
+migraphx_status migraphx_shape_create(migraphx_shape_t* shape,
+                                      migraphx_shape_datatype_t type,
+                                      size_t* lengths,
+                                      size_t lengths_size);
+
+migraphx_status
+migraphx_shape_lengths(const size_t** out, size_t* out_size, const_migraphx_shape_t shape);
+
+migraphx_status
+migraphx_shape_strides(const size_t** out, size_t* out_size, const_migraphx_shape_t shape);
+
+migraphx_status migraphx_shape_type(migraphx_shape_datatype_t* out, const_migraphx_shape_t shape);
+
+migraphx_status migraphx_shape_bytes(size_t* out, const_migraphx_shape_t shape);
+
+migraphx_status
+migraphx_shape_equal(bool* out, const_migraphx_shape_t shape, const_migraphx_shape_t x);
+
+migraphx_status migraphx_argument_destroy(migraphx_argument_t argument);
+
+migraphx_status
+migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer);
+
+migraphx_status migraphx_argument_shape(const_migraphx_shape_t* out,
+                                        const_migraphx_argument_t argument);
+
+migraphx_status migraphx_argument_buffer(char** out, const_migraphx_argument_t argument);
+
+migraphx_status
+migraphx_argument_equal(bool* out, const_migraphx_argument_t argument, const_migraphx_argument_t x);
+
+migraphx_status
+migraphx_argument_generate(migraphx_argument_t* out, const_migraphx_shape_t s, size_t seed);
+
+migraphx_status migraphx_target_destroy(migraphx_target_t target);
+
+migraphx_status migraphx_target_create(migraphx_target_t* target, const char* name);
+
+migraphx_status migraphx_program_parameter_shapes_destroy(
+    migraphx_program_parameter_shapes_t program_parameter_shapes);
+
+migraphx_status migraphx_program_parameter_shapes_size(
+    size_t* out, migraphx_program_parameter_shapes_t program_parameter_shapes);
+
+migraphx_status
+migraphx_program_parameter_shapes_get(const_migraphx_shape_t* out,
+                                      migraphx_program_parameter_shapes_t program_parameter_shapes,
+                                      const char* name);
+
+migraphx_status migraphx_program_parameter_shapes_names(
+    const char** out, migraphx_program_parameter_shapes_t program_parameter_shapes);
+
+migraphx_status
+migraphx_program_parameters_destroy(migraphx_program_parameters_t program_parameters);
+
+migraphx_status
+migraphx_program_parameters_create(migraphx_program_parameters_t* program_parameters);
+
+migraphx_status migraphx_program_parameters_add(migraphx_program_parameters_t program_parameters,
+                                                const char* name,
+                                                const_migraphx_argument_t argument);
+
+migraphx_status migraphx_arguments_destroy(migraphx_arguments_t arguments);
+
+migraphx_status migraphx_arguments_size(size_t* out, migraphx_arguments_t arguments);
+
+migraphx_status
+migraphx_arguments_get(const_migraphx_argument_t* out, migraphx_arguments_t arguments, size_t idx);
+
+migraphx_status migraphx_shapes_destroy(migraphx_shapes_t shapes);
+
+migraphx_status migraphx_shapes_size(size_t* out, migraphx_shapes_t shapes);
+
+migraphx_status
+migraphx_shapes_get(const_migraphx_shape_t* out, migraphx_shapes_t shapes, size_t idx);
+
+migraphx_status migraphx_program_destroy(migraphx_program_t program);
+
+migraphx_status migraphx_program_compile(migraphx_program_t program,
+                                         migraphx_target_t target,
+                                         migraphx_compile_options* options);
+
+migraphx_status migraphx_program_get_parameter_shapes(migraphx_program_parameter_shapes_t* out,
+                                                      migraphx_program_t program);
+
+migraphx_status migraphx_program_get_output_shapes(migraphx_shapes_t* out,
+                                                   migraphx_program_t program);
+
+migraphx_status migraphx_program_print(const_migraphx_program_t program);
+
+migraphx_status migraphx_program_run(migraphx_arguments_t* out,
+                                     migraphx_program_t program,
+                                     migraphx_program_parameters_t params);
+
+migraphx_status
+migraphx_program_equal(bool* out, const_migraphx_program_t program, const_migraphx_program_t x);
+
+migraphx_status
+migraphx_parse_onnx(migraphx_program_t* out, const char* name, migraphx_onnx_options* options);
+
+migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
+                                           const void* data,
+                                           size_t size,
+                                           migraphx_onnx_options* options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/api/include/migraphx/migraphx.hpp

+#ifndef MIGRAPHX_GUARD_API_RTGLIB_MIGRAPHX_HPP
+#define MIGRAPHX_GUARD_API_RTGLIB_MIGRAPHX_HPP
+
+#include <migraphx/migraphx.h>
+#include <memory>
+#include <exception>
+#include <vector>
+#include <cassert>
+
+namespace migraphx {
+inline namespace api { // NOLINT
+
+template <class T, class F, class... Ts>
+T* make(F f, Ts&&... xs)
+{
+    T* result = nullptr;
+    // cppcheck-suppress redundantInitialization
+    // cppcheck-suppress redundantAssignment
+    // cppcheck-suppress unreadVariable
+    auto e = f(&result, std::forward<Ts>(xs)...);
+    if(e != migraphx_status_success)
+        throw std::runtime_error("Failed to call function");
+    return result;
+}
+
+template <class F, class... Ts>
+void call(F f, Ts&&... xs)
+{
+    // cppcheck-suppress redundantInitialization
+    // cppcheck-suppress redundantAssignment
+    // cppcheck-suppress unreadVariable
+    auto e = f(std::forward<Ts>(xs)...);
+    if(e != migraphx_status_success)
+        throw std::runtime_error("Failed to call function");
+}
+
+template <class F, class Iterator = std::size_t>
+struct iota_iterator
+{
+    Iterator index;
+    F f;
+
+    using difference_type   = std::ptrdiff_t;
+    using reference         = decltype(f(std::declval<Iterator>()));
+    using value_type        = typename std::remove_reference<reference>::type;
+    using pointer           = typename std::add_pointer<value_type>::type;
+    using iterator_category = std::input_iterator_tag;
+
+    iota_iterator& operator+=(int n)
+    {
+        index += n;
+        return *this;
+    }
+
+    iota_iterator& operator-=(int n)
+    {
+        index += n;
+        return *this;
+    }
+
+    iota_iterator& operator++()
+    {
+        index++;
+        return *this;
+    }
+
+    iota_iterator& operator--()
+    {
+        index--;
+        return *this;
+    }
+
+    iota_iterator operator++(int) // NOLINT
+    {
+        iota_iterator it = *this;
+        index++;
+        return it;
+    }
+
+    iota_iterator operator--(int) // NOLINT
+    {
+        iota_iterator it = *this;
+        index--;
+        return it;
+    }
+    // TODO: operator->
+    reference operator*() const { return (*f)(index); }
+};
+
+template <class F, class Iterator>
+inline iota_iterator<F, Iterator> operator+(iota_iterator<F, Iterator> x,
+                                            iota_iterator<F, Iterator> y)
+{
+    return iota_iterator<F, Iterator>(x.index + y.index, x.f);
+}
+
+template <class F, class Iterator>
+inline iota_iterator<F, Iterator> operator-(iota_iterator<F, Iterator> x,
+                                            iota_iterator<F, Iterator> y)
+{
+    return iota_iterator<F, Iterator>(x.index - y.index, x.f);
+}
+
+template <class F, class Iterator>
+inline bool operator==(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+{
+    return x.index == y.index;
+}
+
+template <class F, class Iterator>
+inline bool operator!=(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+{
+    return x.index != y.index;
+}
+
+template <class Derived>
+struct array_base
+{
+    const Derived& derived() const { return static_cast<const Derived&>(*this); }
+
+    template <class T>
+    using value_type_t = decltype(std::declval<T>()[0]);
+
+    template <class T>
+    using iterator_t = iota_iterator<typename T::iterator_read>;
+
+    template <class D = Derived>
+    value_type_t<D> front() const
+    {
+        return derived()[0];
+    }
+
+    template <class D = Derived>
+    value_type_t<D> back() const
+    {
+        return derived()[derived().size() - 1];
+    }
+
+    template <class D = Derived>
+    iterator_t<D> begin() const
+    {
+        return {0, {derived().get_handle_ptr()}};
+    }
+
+    template <class D = Derived>
+    iterator_t<D> end() const
+    {
+        return {derived().size(), {derived().get_handle_ptr()}};
+    }
+};
+
+struct own
+{
+};
+struct borrow
+{
+};
+
+template <class T, class D, D Deleter>
+struct handle_base
+{
+    handle_base() : m_handle(nullptr) {}
+    template <class F, class... Ts>
+    void make_handle(F f, Ts&&... xs)
+    {
+        using type = typename std::remove_cv<T>::type;
+        set_handle(make<type>(f, std::forward<Ts>(xs)...), own{});
+    }
+
+    const std::shared_ptr<T>& get_handle() const { return m_handle; }
+
+    T* get_handle_ptr() const
+    {
+        assert(m_handle != nullptr);
+        return get_handle().get();
+    }
+
+    template <class U>
+    void set_handle(U* ptr, own)
+    {
+        m_handle = std::shared_ptr<U>{ptr, Deleter};
+    }
+
+    template <class U>
+    void set_handle(U* ptr, borrow)
+    {
+        m_handle = std::shared_ptr<U>{ptr, [](U*) {}};
+    }
+
+    protected:
+    std::shared_ptr<T> m_handle;
+};
+
+#define MIGRAPHX_DETAIL_HANDLE_BASE(name, const_)     \
+    handle_base<const_ migraphx_##name,               \
+                decltype(&migraphx_##name##_destroy), \
+                migraphx_##name##_destroy>
+
+// NOLINTNEXTLINE
+#define MIGRAPHX_HANDLE_BASE(name) MIGRAPHX_DETAIL_HANDLE_BASE(name, )
+// NOLINTNEXTLINE
+#define MIGRAPHX_CONST_HANDLE_BASE(name) MIGRAPHX_DETAIL_HANDLE_BASE(name, const)
+
+struct shape : MIGRAPHX_CONST_HANDLE_BASE(shape)
+{
+    shape() {}
+
+    shape(const migraphx_shape* p) { this->set_handle(p, borrow{}); }
+
+    shape(migraphx_shape* p, own) { this->set_handle(p, own{}); }
+
+    shape(migraphx_shape* p, borrow) { this->set_handle(p, borrow{}); }
+
+    shape(migraphx_shape_datatype_t type, std::vector<size_t> plengths)
+    {
+        this->make_handle(&migraphx_shape_create, type, plengths.data(), plengths.size());
+    }
+
+    std::vector<size_t> lengths() const
+    {
+        const size_t* pout;
+        size_t pout_size;
+        call(&migraphx_shape_lengths, &pout, &pout_size, this->get_handle_ptr());
+        return std::vector<size_t>(pout, pout + pout_size);
+    }
+
+    std::vector<size_t> strides() const
+    {
+        const size_t* pout;
+        size_t pout_size;
+        call(&migraphx_shape_strides, &pout, &pout_size, this->get_handle_ptr());
+        return std::vector<size_t>(pout, pout + pout_size);
+    }
+
+    migraphx_shape_datatype_t type() const
+    {
+        migraphx_shape_datatype_t pout;
+        call(&migraphx_shape_type, &pout, this->get_handle_ptr());
+        return pout;
+    }
+
+    size_t bytes() const
+    {
+        size_t pout;
+        call(&migraphx_shape_bytes, &pout, this->get_handle_ptr());
+        return pout;
+    }
+
+    friend bool operator==(const shape& px, const shape& py)
+    {
+        bool pout;
+        call(&migraphx_shape_equal, &pout, px.get_handle_ptr(), py.get_handle_ptr());
+        return pout;
+    }
+
+    friend bool operator!=(const shape& px, const shape& py) { return !(px == py); }
+};
+
+struct argument : MIGRAPHX_CONST_HANDLE_BASE(argument)
+{
+    argument() {}
+
+    argument(migraphx_argument* p, borrow) { this->set_handle(p, borrow{}); }
+
+    argument(migraphx_argument* p, own) { this->set_handle(p, own{}); }
+
+    argument(const migraphx_argument* p) { this->set_handle(p, borrow{}); }
+
+    argument(shape pshape, void* pbuffer)
+    {
+        this->make_handle(&migraphx_argument_create, pshape.get_handle_ptr(), pbuffer);
+    }
+
+    shape get_shape() const
+    {
+        const_migraphx_shape_t pout;
+        call(&migraphx_argument_shape, &pout, this->get_handle_ptr());
+        return shape(pout);
+    }
+
+    char* data() const
+    {
+        char* pout;
+        call(&migraphx_argument_buffer, &pout, this->get_handle_ptr());
+        return pout;
+    }
+
+    static argument generate(shape ps, size_t pseed = 0)
+    {
+        return argument(
+            make<migraphx_argument>(&migraphx_argument_generate, ps.get_handle_ptr(), pseed),
+            own{});
+    }
+
+    friend bool operator==(const argument& px, const argument& py)
+    {
+        bool pout;
+        call(&migraphx_argument_equal, &pout, px.get_handle_ptr(), py.get_handle_ptr());
+        return pout;
+    }
+
+    friend bool operator!=(const argument& px, const argument& py) { return !(px == py); }
+};
+
+struct target : MIGRAPHX_HANDLE_BASE(target)
+{
+    target() {}
+
+    target(migraphx_target* p, own) { this->set_handle(p, own{}); }
+
+    target(migraphx_target* p, borrow) { this->set_handle(p, borrow{}); }
+
+    target(const char* name) { this->make_handle(&migraphx_target_create, name); }
+};
+
+struct program_parameter_shapes : MIGRAPHX_HANDLE_BASE(program_parameter_shapes)
+{
+    program_parameter_shapes() {}
+
+    program_parameter_shapes(migraphx_program_parameter_shapes* p, own)
+    {
+        this->set_handle(p, own{});
+    }
+
+    program_parameter_shapes(migraphx_program_parameter_shapes* p, borrow)
+    {
+        this->set_handle(p, borrow{});
+    }
+
+    size_t size() const
+    {
+        size_t pout;
+        call(&migraphx_program_parameter_shapes_size, &pout, this->get_handle_ptr());
+        return pout;
+    }
+
+    shape operator[](const char* pname) const
+    {
+        const_migraphx_shape_t pout;
+        call(&migraphx_program_parameter_shapes_get, &pout, this->get_handle_ptr(), pname);
+        return shape(pout);
+    }
+
+    std::vector<const char*> names() const
+    {
+        std::vector<const char*> result(this->size());
+        call(&migraphx_program_parameter_shapes_names, result.data(), this->get_handle_ptr());
+        return result;
+    }
+};
+
+struct program_parameters : MIGRAPHX_HANDLE_BASE(program_parameters)
+{
+    program_parameters(migraphx_program_parameters* p, own) { this->set_handle(p, own{}); }
+
+    program_parameters(migraphx_program_parameters* p, borrow) { this->set_handle(p, borrow{}); }
+
+    program_parameters() { this->make_handle(&migraphx_program_parameters_create); }
+
+    void add(const char* pname, const argument& pargument) const
+    {
+        call(&migraphx_program_parameters_add,
+             this->get_handle_ptr(),
+             pname,
+             pargument.get_handle_ptr());
+    }
+};
+
+struct arguments : MIGRAPHX_HANDLE_BASE(arguments), array_base<arguments>
+{
+    arguments(migraphx_arguments* p, own) { this->set_handle(p, own{}); }
+
+    arguments(migraphx_arguments* p, borrow) { this->set_handle(p, borrow{}); }
+
+    size_t size() const
+    {
+        size_t pout;
+        call(&migraphx_arguments_size, &pout, this->get_handle_ptr());
+        return pout;
+    }
+
+    argument operator[](size_t pidx) const
+    {
+        const_migraphx_argument_t pout;
+        call(&migraphx_arguments_get, &pout, this->get_handle_ptr(), pidx);
+        return argument(pout);
+    }
+
+    struct iterator_read
+    {
+        migraphx_arguments* self;
+        argument operator()(size_t pidx) const
+        {
+            const_migraphx_argument_t pout;
+            call(&migraphx_arguments_get, &pout, self, pidx);
+            return argument(pout);
+        }
+    };
+};
+
+struct shapes : MIGRAPHX_HANDLE_BASE(shapes), array_base<shapes>
+{
+    shapes(migraphx_shapes* p, own) { this->set_handle(p, own{}); }
+
+    shapes(migraphx_shapes* p, borrow) { this->set_handle(p, borrow{}); }
+
+    size_t size() const
+    {
+        size_t pout;
+        call(&migraphx_shapes_size, &pout, this->get_handle_ptr());
+        return pout;
+    }
+
+    shape operator[](size_t pidx) const
+    {
+        const_migraphx_shape_t pout;
+        call(&migraphx_shapes_get, &pout, this->get_handle_ptr(), pidx);
+        return shape(pout);
+    }
+
+    struct iterator_read
+    {
+        migraphx_shapes* self;
+        shape operator()(size_t pidx) const
+        {
+            const_migraphx_shape_t pout;
+            call(&migraphx_shapes_get, &pout, self, pidx);
+            return shape(pout);
+        }
+    };
+};
+
+struct program : MIGRAPHX_HANDLE_BASE(program)
+{
+    program() {}
+
+    program(migraphx_program* p, own) { this->set_handle(p, own{}); }
+
+    program(migraphx_program* p, borrow) { this->set_handle(p, borrow{}); }
+
+    void compile(const target& ptarget, migraphx_compile_options poptions) const
+    {
+        call(
+            &migraphx_program_compile, this->get_handle_ptr(), ptarget.get_handle_ptr(), &poptions);
+    }
+
+    void compile(const target& ptarget) const
+    {
+        call(&migraphx_program_compile, this->get_handle_ptr(), ptarget.get_handle_ptr(), nullptr);
+    }
+
+    program_parameter_shapes get_parameter_shapes() const
+    {
+        migraphx_program_parameter_shapes_t pout;
+        call(&migraphx_program_get_parameter_shapes, &pout, this->get_handle_ptr());
+        return program_parameter_shapes(pout, own{});
+    }
+
+    shapes get_output_shapes() const
+    {
+        migraphx_shapes_t pout;
+        call(&migraphx_program_get_output_shapes, &pout, this->get_handle_ptr());
+        return shapes(pout, own{});
+    }
+
+    arguments eval(const program_parameters& pparams) const
+    {
+        migraphx_arguments_t pout;
+        call(&migraphx_program_run, &pout, this->get_handle_ptr(), pparams.get_handle_ptr());
+        return arguments(pout, own{});
+    }
+
+    void print() const { call(&migraphx_program_print, this->get_handle_ptr()); }
+
+    friend bool operator==(const program& px, const program& py)
+    {
+        bool pout;
+        call(&migraphx_program_equal, &pout, px.get_handle_ptr(), py.get_handle_ptr());
+        return pout;
+    }
+
+    friend bool operator!=(const program& px, const program& py) { return !(px == py); }
+};
+
+inline program parse_onnx(const char* filename, migraphx_onnx_options options)
+{
+    return program(make<migraphx_program>(&migraphx_parse_onnx, filename, &options), own{});
+}
+
+inline program parse_onnx(const char* filename)
+{
+    return program(make<migraphx_program>(&migraphx_parse_onnx, filename, nullptr), own{});
+}
+
+inline program parse_onnx_buffer(const void* data, size_t size, migraphx_onnx_options options)
+{
+    return program(make<migraphx_program>(&migraphx_parse_onnx_buffer, data, size, &options),
+                   own{});
+}
+
+inline program parse_onnx_buffer(const void* data, size_t size)
+{
+    return program(make<migraphx_program>(&migraphx_parse_onnx_buffer, data, size, nullptr), own{});
+}
+
+inline program parse_onnx_buffer(const std::string& buffer, migraphx_onnx_options options)
+{
+    return program(
+        make<migraphx_program>(&migraphx_parse_onnx_buffer, buffer.data(), buffer.size(), &options),
+        own{});
+}
+
+inline program parse_onnx_buffer(const std::string& buffer)
+{
+    return program(
+        make<migraphx_program>(&migraphx_parse_onnx_buffer, buffer.data(), buffer.size(), nullptr),
+        own{});
+}
+
+} // namespace api
+} // namespace migraphx
+
+#endif

src/api/migraphx.py

+import api
+
+
+def bad_param_error(msg):
+    return 'MIGRAPHX_THROW(migraphx_status_bad_param, "{}")'.format(msg)
+
+
+api.error_type = 'migraphx_status'
+api.success_type = 'migraphx_status_success'
+api.try_wrap = 'migraphx::try_'
+api.bad_param_error = bad_param_error
+
+
+@api.cwrap('migraphx::shape::type_t')
+def shape_type_wrap(p):
+    if p.returns:
+        p.add_param('migraphx_shape_datatype_t *')
+        p.bad_param('${name} == nullptr', 'Null pointer')
+        p.write = ['*${name} = migraphx::to_shape_type(${result})']
+    else:
+        p.add_param('migraphx_shape_datatype_t')
+        p.read = 'migraphx::to_shape_type(${name})'
+
+
+@api.cwrap('migraphx::compile_options')
+def compile_options_type_wrap(p):
+    if p.returns:
+        p.add_param('migraphx_compile_options *')
+        p.bad_param('${name} == nullptr', 'Null pointer')
+        p.write = ['*${name} = migraphx::to_compile_options(${result})']
+    else:
+        p.add_param('migraphx_compile_options *')
+        p.read = '${name} == nullptr ? migraphx::compile_options{} : migraphx::to_compile_options(*${name})'
+
+
+@api.cwrap('migraphx::onnx_options')
+def onnx_options_type_wrap(p):
+    if p.returns:
+        p.add_param('migraphx_onnx_options *')
+        p.bad_param('${name} == nullptr', 'Null pointer')
+        p.write = ['*${name} = migraphx::to_onnx_options(${result})']
+    else:
+        p.add_param('migraphx_onnx_options *')
+        p.read = '${name} == nullptr ? migraphx::onnx_options{} : migraphx::to_onnx_options(*${name})'
+
+
+def auto_handle(f):
+    return api.handle('migraphx_' + f.__name__, 'migraphx::' + f.__name__)(f)
+
+
+@auto_handle
+def shape(h):
+    h.constructor(
+        'create',
+        api.params(type='migraphx::shape::type_t',
+                   lengths='std::vector<size_t>'))
+    h.method('lengths',
+             fname='lens',
+             returns='const std::vector<size_t>&',
+             const=True)
+    h.method('strides', returns='const std::vector<size_t>&', const=True)
+    h.method('type', returns='migraphx::shape::type_t', const=True)
+    h.method('bytes', returns='size_t', const=True)
+    h.method('equal',
+             api.params(x='const migraphx::shape&'),
+             invoke='migraphx::equal($@)',
+             returns='bool',
+             const=True)
+
+
+@auto_handle
+def argument(h):
+    h.constructor('create',
+                  api.params(shape='const migraphx::shape&', buffer='void*'))
+    h.method('shape',
+             fname='get_shape',
+             cpp_name='get_shape',
+             returns='const migraphx::shape&',
+             const=True)
+    h.method('buffer',
+             fname='data',
+             cpp_name='data',
+             returns='char*',
+             const=True)
+    h.method('equal',
+             api.params(x='const migraphx::argument&'),
+             invoke='migraphx::equal($@)',
+             returns='bool',
+             const=True)
+
+
+api.add_function('migraphx_argument_generate',
+                 api.params(s='const migraphx::shape&', seed='size_t'),
+                 fname='migraphx::generate_argument',
+                 returns='migraphx::argument')
+
+
+@auto_handle
+def target(h):
+    h.constructor('create',
+                  api.params(name='const char*'),
+                  fname='migraphx::get_target')
+
+
+@api.handle('migraphx_program_parameter_shapes',
+            'std::unordered_map<std::string, migraphx::shape>')
+def program_parameter_shapes(h):
+    h.method('size', returns='size_t')
+    h.method('get',
+             api.params(name='const char*'),
+             fname='at',
+             cpp_name='operator[]',
+             returns='const migraphx::shape&')
+    h.method('names',
+             invoke='migraphx::get_names(${program_parameter_shapes})',
+             returns='std::vector<const char*>')
+
+
+@api.handle('migraphx_program_parameters',
+            'std::unordered_map<std::string, migraphx::argument>')
+def program_parameters(h):
+    h.constructor('create')
+    h.method('add',
+             api.params(name='const char*',
+                        argument='const migraphx::argument&'),
+             invoke='${program_parameters}[${name}] = ${argument}')
+
+
+@api.handle('migraphx_arguments', 'std::vector<migraphx::argument>')
+def arguments(h):
+    h.method('size', returns='size_t')
+    h.method('get',
+             api.params(idx='size_t'),
+             fname='at',
+             cpp_name='operator[]',
+             returns='const migraphx::argument&')
+
+
+@api.handle('migraphx_shapes', 'std::vector<migraphx::shape>')
+def shapes(h):
+    h.method('size', returns='size_t')
+    h.method('get',
+             api.params(idx='size_t'),
+             fname='at',
+             cpp_name='operator[]',
+             returns='const migraphx::shape&')
+
+
+@auto_handle
+def program(h):
+    h.method(
+        'compile',
+        api.params(target='migraphx::target',
+                   options='migraphx::compile_options'))
+    h.method('get_parameter_shapes',
+             returns='std::unordered_map<std::string, migraphx::shape>')
+    h.method('get_output_shapes',
+             invoke='migraphx::get_output_shapes($@)',
+             returns='std::vector<migraphx::shape>')
+    h.method('print', invoke='migraphx::print($@)', const=True)
+    h.method('run',
+             api.params(
+                 params='std::unordered_map<std::string, migraphx::argument>'),
+             invoke='migraphx::run($@)',
+             returns='std::vector<migraphx::argument>')
+    h.method('equal',
+             api.params(x='const migraphx::program&'),
+             invoke='migraphx::equal($@)',
+             returns='bool',
+             const=True)
+
+
+api.add_function('migraphx_parse_onnx',
+                 api.params(name='const char*',
+                            options='migraphx::onnx_options'),
+                 fname='migraphx::parse_onnx',
+                 returns='migraphx::program')
+
+api.add_function('migraphx_parse_onnx_buffer',
+                 api.params(data='const void*',
+                            size='size_t',
+                            options='migraphx::onnx_options'),
+                 fname='migraphx::parse_onnx_buffer',
+                 returns='migraphx::program')

src/driver/main.cpp

@@ -62,9 +62,9 @@ struct loader
             }
             std::cout << "Reading: " << file << std::endl;
             if(file_type == "onnx")
-                p = parse_onnx(file);
+                p = parse_onnx(file, onnx_options{batch});
             else if(file_type == "tf")
-                p = parse_tf(file, is_nhwc);
+                p = parse_tf(file, tf_options{is_nhwc, batch});
         }
         else
         {

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

@@ -69,6 +69,10 @@ void eliminate_contiguous::apply(program& p) const
 {
     for(auto ins : iterator_for(p))
     {
+        // return instruction should have inputs with standard shape
+        if(ins->name() == "@return")
+            continue;
+
         // Make a copy so we can modify it while we iterate
         auto args = ins->inputs();
         for(auto arg : ins->inputs())

src/include/migraphx/builtin.hpp

@@ -63,6 +63,16 @@ struct param
     }
 };
 
+struct returns
+{
+    std::string name() const { return "@return"; }
+    shape compute_shape(const std::vector<shape>&) const { return {}; }
+    argument compute(context&, const shape&, const std::vector<argument>&) const
+    {
+        MIGRAPHX_THROW("builtin");
+    }
+};
+
 } // namespace builtin
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

src/include/migraphx/concat_opt.hpp

@@ -62,11 +62,17 @@ struct concat_optimization
     template <typename PrivateDetailTypeErasedT>
     concat_optimization& operator=(PrivateDetailTypeErasedT value)
     {
-        if(private_detail_te_handle_mem_var.unique())
-            *private_detail_te_handle_mem_var = std::forward<PrivateDetailTypeErasedT>(value);
-        else if(!private_detail_te_handle_mem_var)
-            private_detail_te_handle_mem_var = std::make_shared<PrivateDetailTypeErasedT>(
-                std::forward<PrivateDetailTypeErasedT>(value));
+        using std::swap;
+        auto* derived = this->any_cast<PrivateDetailTypeErasedT>();
+        if(derived and private_detail_te_handle_mem_var.unique())
+        {
+            *derived = std::forward<PrivateDetailTypeErasedT>(value);
+        }
+        else
+        {
+            concat_optimization rhs(value);
+            swap(private_detail_te_handle_mem_var, rhs.private_detail_te_handle_mem_var);
+        }
         return *this;
     }
 
@@ -74,7 +80,7 @@ struct concat_optimization
     template <typename PrivateDetailTypeErasedT>
     PrivateDetailTypeErasedT* any_cast()
     {
-        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT)
+        return this->type_id() == typeid(PrivateDetailTypeErasedT)
                    ? std::addressof(static_cast<private_detail_te_handle_type<
                                         typename std::remove_cv<PrivateDetailTypeErasedT>::type>&>(
                                         private_detail_te_get_handle())
@@ -85,7 +91,7 @@ struct concat_optimization
     template <typename PrivateDetailTypeErasedT>
     const typename std::remove_cv<PrivateDetailTypeErasedT>::type* any_cast() const
     {
-        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT)
+        return this->type_id() == typeid(PrivateDetailTypeErasedT)
                    ? std::addressof(static_cast<const private_detail_te_handle_type<
                                         typename std::remove_cv<PrivateDetailTypeErasedT>::type>&>(
                                         private_detail_te_get_handle())

src/include/migraphx/context.hpp

@@ -53,11 +53,17 @@ struct context
     template <typename PrivateDetailTypeErasedT>
     context& operator=(PrivateDetailTypeErasedT value)
     {
-        if(private_detail_te_handle_mem_var.unique())
-            *private_detail_te_handle_mem_var = std::forward<PrivateDetailTypeErasedT>(value);
-        else if(!private_detail_te_handle_mem_var)
-            private_detail_te_handle_mem_var = std::make_shared<PrivateDetailTypeErasedT>(
-                std::forward<PrivateDetailTypeErasedT>(value));
+        using std::swap;
+        auto* derived = this->any_cast<PrivateDetailTypeErasedT>();
+        if(derived and private_detail_te_handle_mem_var.unique())
+        {
+            *derived = std::forward<PrivateDetailTypeErasedT>(value);
+        }
+        else
+        {
+            context rhs(value);
+            swap(private_detail_te_handle_mem_var, rhs.private_detail_te_handle_mem_var);
+        }
         return *this;
     }
 
@@ -65,7 +71,7 @@ struct context
     template <typename PrivateDetailTypeErasedT>
     PrivateDetailTypeErasedT* any_cast()
     {
-        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT)
+        return this->type_id() == typeid(PrivateDetailTypeErasedT)
                    ? std::addressof(static_cast<private_detail_te_handle_type<
                                         typename std::remove_cv<PrivateDetailTypeErasedT>::type>&>(
                                         private_detail_te_get_handle())
@@ -76,7 +82,7 @@ struct context
     template <typename PrivateDetailTypeErasedT>
     const typename std::remove_cv<PrivateDetailTypeErasedT>::type* any_cast() const
     {
-        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT)
+        return this->type_id() == typeid(PrivateDetailTypeErasedT)
                    ? std::addressof(static_cast<const private_detail_te_handle_type<
                                         typename std::remove_cv<PrivateDetailTypeErasedT>::type>&>(
                                         private_detail_te_get_handle())

src/include/migraphx/errors.hpp

@@ -12,7 +12,10 @@ inline namespace MIGRAPHX_INLINE_NS {
 /// Represents exceptions that can be thrown by migraphxlib
 struct exception : std::runtime_error
 {
-    exception(const std::string& msg = "") : std::runtime_error(msg) {}
+    unsigned int error;
+    exception(unsigned int e = 0, const std::string& msg = "") : std::runtime_error(msg), error(e)
+    {
+    }
 };
 
 /**
@@ -24,7 +27,13 @@ struct exception : std::runtime_error
  */
 inline exception make_exception(const std::string& context, const std::string& message = "")
 {
-    return {context + ": " + message};
+    return {0, context + ": " + message};
+}
+
+inline exception
+make_exception(const std::string& context, unsigned int e, const std::string& message = "")
+{
+    return {e, context + ": " + message};
 }
 
 /**