Merge pull request #2019 from ROCmSoftwarePlatform/rel57_workitems

.githooks/pre-commit

@@ -4,62 +4,7 @@
 # are installed, and if so, uses the installed version to format
 # the staged changes.
 
-base=clang-format-10
-format=""
-yapf_base=yapf
-yapf_format=""
-
-use_yapf=true
-
-# Redirect output to stderr.
-exec 1>&2
-
-# check if clang-format is installed
-type "$base" >/dev/null 2>&1 && format="$base"
-
-# no versions of clang-format are installed
-if [ -z "$format" ]
-then
-    echo "$base is not installed. Pre-commit hook will not be executed."
-    exit 0
-fi
-
-# check if yapf is installed
-type "$yapf_base" >/dev/null 2>&1 && yapf_format="$yapf_base"
-
-# no versions of yapf are installed
-if [ -z "$yapf_format" ]
-then
-    echo "$yapf_base is not installed. Pre-commit hook for python files will not be executed"
-    use_yapf=false
-fi
-
 # Do everything from top - level
 cd $(git rev-parse --show-toplevel)
 
-if git rev-parse --verify HEAD >/dev/null 2>&1
-then
-    against=HEAD
-else
-    # Initial commit: diff against an empty tree object
-    against=16bbb57
-fi
-
-# do the formatting
-for file in $(git diff-index --cached --name-only $against | grep -E '\.h$|\.hpp$|\.cpp$|\.cl$|\.c$|\.h\.in$|\.hpp\.in$|\.cpp\.in$|\.py$')
-do
-    if [ -e "$file" ]
-    then
-        if [ $(echo $file | grep -E '\.py$') ]
-        then
-            if $use_yapf
-            then
-                echo "$yapf_format $file"
-                "$yapf_format" -i "$file"
-            fi
-        else
-            echo "$format $file"
-            "$format" -i -style=file "$file"
-        fi
-    fi
-done
+python3 tools/format.py -q -i HEAD

.github/workflows/ci.yaml

@@ -144,6 +144,8 @@ jobs:
     runs-on: ROCM-Ubuntu
     steps:
     - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
 
     # In this step, this action saves a list of existing images,
     # the cache is created without them in the post run.
@@ -164,19 +166,8 @@ jobs:
       shell: bash -c "docker run -i -v=$GITHUB_WORKSPACE:/data -w /data migraphx bash < {0}"
       run: |
         set -e
-        find . -iname '*.h' \
-              -o -iname '*.hpp' \
-              -o -iname '*.cpp' \
-              -o -iname '*.h.in' \
-              -o -iname '*.hpp.in' \
-              -o -iname '*.cpp.in' \
-              -o -iname '*.cl' \
-              -o -iname '*.c' \
-          | grep -v 'build/' \
-          | xargs -n 1 -P 1 -I{} -t sh -c 'clang-format-10 -style=file {} | diff - {}'
-          find . -iname '*.py' \
-          | grep -v 'build/'  \
-          | xargs -n 1 -P 1 -I{} -t sh -c 'yapf {} | diff - {}'
+        git config --global --add safe.directory /data
+        python3 tools/format.py origin/${{ github.event_name == 'pull_request' && github.base_ref || 'develop' }}
 
   pyflakes:
     runs-on: ubuntu-20.04
@@ -323,6 +314,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
+        set +x
         gh extension install actions/gh-actions-cache --pin v1.0.1
         gh actions-cache delete ${{ steps.ccache_restore.outputs.cache-matched-key }} --confirm
 
@@ -439,6 +431,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
+        set +x
         gh extension install actions/gh-actions-cache
         gh actions-cache delete ${{ steps.ccache_restore_fpga.outputs.cache-matched-key }} --confirm
       continue-on-error: true

.github/workflows/performance.yaml

@@ -12,7 +12,7 @@ on:
       rocm_release:
         description: ROCm Version
         required: true
-        default: '5.5'
+        default: '5.6'
       performance_reports_repo:
         description: Repository where performance reports are stored
         required: true
@@ -42,13 +42,15 @@ on:
         required: true
         default: '-r'
 
-concurrency: "perftest-${{ github.head_ref ||  github.base_ref || 'schedule' }}"
+concurrency: 
+  group: "perftest-${{ github.head_ref ||  github.base_ref || 'schedule' }}"
+  cancel-in-progress: true
 
 jobs:
   release:
     uses: ROCmSoftwarePlatform/migraphx-benchmark/.github/workflows/perf-test.yml@main
     with:
-      rocm_release: ${{ github.event.inputs.rocm_release || '5.5' }}
+      rocm_release: ${{ github.event.inputs.rocm_release || '5.6' }}
       result_number: ${{ github.event.inputs.result_number || '10' }}
       flags: ${{ github.event.inputs.flags || '-r' }}
       performance_reports_repo: ${{ github.event.inputs.performance_reports_repo || 'ROCmSoftwarePlatform/migraphx-reports' }}

.gitignore

@@ -70,5 +70,13 @@ docs/_images
 docs/_static
 docs/_templates
 docs/.doxygen/docBin
+docs/.doxygen/DoxygenWarningLog.txt
 docs/_doxygen
+docs/html
 /_readthedocs
+
+# JetBrains config directories (ignoring symlinks)
+.idea/
+cmake-build*/
+build*/
+

Dockerfile

@@ -19,7 +19,6 @@ RUN sh -c "echo 'Package: *\nPin: release o=repo.radeon.com\nPin-priority: 600'
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --allow-unauthenticated \
     apt-utils \
     build-essential \
-    clang-format-10 \
     cmake \
     curl \
     doxygen \
@@ -97,7 +96,8 @@ RUN /download_models.sh && rm /download_models.sh
 # Install latest ccache version
 RUN cget -p $PREFIX install facebook/zstd@v1.4.5 -X subdir -DCMAKE_DIR=build/cmake
 RUN cget -p $PREFIX install ccache@v4.1 -DENABLE_TESTING=OFF
-RUN cget -p /opt/cmake install kitware/cmake@v3.24.3
+RUN cget -p /opt/cmake install kitware/cmake@v3.26.4
+
 
 COPY ./test/onnx/.onnxrt-commit /
 

Jenkinsfile

@@ -15,20 +15,18 @@ def rocmtestnode(Map conf) {
         def compiler = bconf.get("compiler", "/opt/rocm/llvm/bin/clang++")
         def flags = bconf.get("flags", "")
         def gpu_debug = bconf.get("gpu_debug", "0")
-        def hiprtc_workarounds = bconf.get("hiprtc_workarounds", "0")
         def cmd = """
             ulimit -c unlimited
             echo "leak:dnnl::impl::malloc" > suppressions.txt
             export LSAN_OPTIONS="suppressions=\$(pwd)/suppressions.txt"
             export MIGRAPHX_GPU_DEBUG=${gpu_debug}
-            export MIGRAPHX_ENABLE_HIPRTC_WORKAROUNDS=${hiprtc_workarounds}
             export CXX=${compiler}
             export CXXFLAGS='-Werror'
             env
             rm -rf build
             mkdir build
             cd build
-            cmake -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DBUILD_DEV=On ${flags} ..
+            cmake -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DBUILD_DEV=On -DCMAKE_EXECUTE_PROCESS_COMMAND_ECHO=STDOUT ${flags} ..
             git diff
             git diff-index --quiet HEAD || (echo "Git repo is not clean after running cmake." && exit 1)
             make -j\$(nproc) generate VERBOSE=1
@@ -90,9 +88,9 @@ def rocmnodename(name) {
     } else if(name == "navi21") {
         node_name = "${rocmtest_name} && navi21";
     } else if(name == "mi100+") {
-        node_name = "${rocmtest_name} && (gfx908 || gfx90a)";
-    } else if(name == "anygpu") {
-        node_name = "${rocmtest_name} && (gfx908 || gfx90a || vega)";
+        node_name = "${rocmtest_name} && (gfx908 || gfx90a) && !vm";
+    } else if(name == "cdna") {
+        node_name = "${rocmtest_name} && (gfx908 || gfx90a || vega20) && !vm";
     } else if(name == "nogpu") {
         node_name = "${rocmtest_name} && nogpu";
     }
@@ -105,30 +103,22 @@ def rocmnode(name, body) {
     }
 }
 
-rocmtest clang_debug: rocmnode('vega') { cmake_build ->
-    stage('Hip Clang Debug') {
+rocmtest clang_debug: rocmnode('cdna') { cmake_build ->
+    stage('hipRTC Debug') {
         def sanitizers = "undefined"
         def debug_flags = "-g -O2 -fsanitize=${sanitizers} -fno-sanitize-recover=${sanitizers}"
-        cmake_build(flags: "-DCMAKE_BUILD_TYPE=debug -DMIGRAPHX_ENABLE_PYTHON=Off -DCMAKE_CXX_FLAGS_DEBUG='${debug_flags}' -DCMAKE_C_FLAGS_DEBUG='${debug_flags}'")
+        cmake_build(flags: "-DCMAKE_BUILD_TYPE=debug -DMIGRAPHX_ENABLE_PYTHON=Off -DCMAKE_CXX_FLAGS_DEBUG='${debug_flags}' -DCMAKE_C_FLAGS_DEBUG='${debug_flags}' -DMIGRAPHX_USE_HIPRTC=On", gpu_debug: true)
     }
-}, clang_gpu_debug: rocmnode('vega') { cmake_build ->
-    stage('Hip Clang GPU Debug') {
-        cmake_build(flags: "-DCMAKE_BUILD_TYPE=release", gpu_debug: true)
-    }
-}, clang_release: rocmnode('vega') { cmake_build ->
+}, clang_release: rocmnode('cdna') { cmake_build ->
     stage('Hip Clang Release') {
         cmake_build(flags: "-DCMAKE_BUILD_TYPE=release")
         stash includes: 'build/*.deb', name: 'migraphx-package'
     }
-}, hiprtc_gpu_debug: rocmnode('vega') { cmake_build ->
-    stage('HipRTC GPU Debug') {
-        cmake_build(flags: "-DCMAKE_BUILD_TYPE=release -DMIGRAPHX_USE_HIPRTC=On", gpu_debug: true, hiprtc_workarounds: true)
-    }
-}, all_targets_debug : rocmnode('vega') { cmake_build ->
+}, all_targets_debug : rocmnode('cdna') { cmake_build ->
     stage('All targets Release') {
         cmake_build(flags: "-DCMAKE_BUILD_TYPE=release -DMIGRAPHX_ENABLE_GPU=On -DMIGRAPHX_ENABLE_CPU=On -DMIGRAPHX_ENABLE_FPGA=On") 
     }
-}, mlir_debug: rocmnode('vega') { cmake_build ->
+}, mlir_debug: rocmnode('cdna') { cmake_build ->
     stage('MLIR Debug') {
         withEnv(['MIGRAPHX_ENABLE_MLIR=1']) {
             def sanitizers = "undefined"
@@ -165,7 +155,7 @@ def onnxnode(name, body) {
     }
 }
 
-rocmtest onnx: onnxnode('anygpu') { cmake_build ->
+rocmtest onnx: onnxnode('cdna') { cmake_build ->
     stage("Onnx runtime") {
         sh '''
             apt install half

cmake/Embed.cmake

@@ -24,11 +24,7 @@
 find_program(EMBED_LD ld)
 find_program(EMBED_OBJCOPY objcopy)
 
-if(LINUX)
-    option(EMBED_USE_LD "Use ld to embed data files" ON)
-else()
-    option(EMBED_USE_LD "Use ld to embed data files" OFF)
-endif()
+option(EMBED_USE_LD "Use ld to embed data files" OFF)
 
 function(wrap_string)
     set(options)
@@ -60,8 +56,8 @@ endfunction()
 
 function(generate_embed_source EMBED_NAME)
     set(options)
-    set(oneValueArgs SRC HEADER)
-    set(multiValueArgs OBJECTS SYMBOLS)
+    set(oneValueArgs SRC HEADER RELATIVE)
+    set(multiValueArgs OBJECTS SYMBOLS FILES)
 
     cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
@@ -78,6 +74,8 @@ function(generate_embed_source EMBED_NAME)
     foreach(idx RANGE ${LEN})
         list(GET PARSE_SYMBOLS ${idx} SYMBOL)
         list(GET PARSE_OBJECTS ${idx} OBJECT)
+        list(GET PARSE_FILES ${idx} FILE)
+
         set(START_SYMBOL "_binary_${SYMBOL}_start")
         set(END_SYMBOL "_binary_${SYMBOL}_end")
         if(EMBED_USE_LD)
@@ -92,9 +90,11 @@ function(generate_embed_source EMBED_NAME)
             ")
         endif()
 
-        # TODO: Should use NAME_WLE
-        get_filename_component(BASE_NAME "${OBJECT}" NAME)
-        string(REGEX REPLACE ".[A-Za-z0-9_]+$" "" BASE_NAME ${BASE_NAME})
+        if(PARSE_RELATIVE)
+            file(RELATIVE_PATH BASE_NAME ${PARSE_RELATIVE} "${FILE}")
+        else()
+            get_filename_component(BASE_NAME "${FILE}" NAME)
+        endif()
 
         string(APPEND INIT_KERNELS "
             { \"${BASE_NAME}\", { ${START_SYMBOL}, ${END_SYMBOL}} },
@@ -162,6 +162,11 @@ function(embed_file OUTPUT_FILE OUTPUT_SYMBOL FILE)
 endfunction()
 
 function(add_embed_library EMBED_NAME)
+    set(options)
+    set(oneValueArgs RELATIVE)
+    set(multiValueArgs)
+    cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
     file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/embed)
     file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/embed/${EMBED_NAME})
     set(EMBED_DIR ${CMAKE_CURRENT_BINARY_DIR}/embed/${EMBED_NAME})
@@ -171,15 +176,26 @@ function(add_embed_library EMBED_NAME)
     set(OUTPUT_FILES)
     set(SYMBOLS)
     message(STATUS "Embedding files")
-    foreach(FILE ${ARGN})
+    foreach(FILE ${PARSE_UNPARSED_ARGUMENTS})
         embed_file(OUTPUT_FILE OUTPUT_SYMBOL ${FILE})
         list(APPEND OUTPUT_FILES ${OUTPUT_FILE})
         list(APPEND SYMBOLS ${OUTPUT_SYMBOL})
     endforeach()
     message(STATUS "Generating embedding library ${EMBED_NAME}")
-    generate_embed_source(${EMBED_NAME} SRC ${SRC_FILE} HEADER ${HEADER_FILE} OBJECTS ${OUTPUT_FILES} SYMBOLS ${SYMBOLS})
-    add_library(${EMBED_NAME} STATIC ${OUTPUT_FILES} "${SRC_FILE}")
-    target_include_directories(${EMBED_NAME} PUBLIC "${EMBED_DIR}/include")
-    target_compile_options(${EMBED_NAME} PRIVATE -Wno-reserved-identifier -Wno-extern-initializer -Wno-missing-variable-declarations)
-    set_target_properties(${EMBED_NAME} PROPERTIES POSITION_INDEPENDENT_CODE On)
+    generate_embed_source(${EMBED_NAME} SRC ${SRC_FILE} HEADER ${HEADER_FILE} OBJECTS ${OUTPUT_FILES} SYMBOLS ${SYMBOLS} RELATIVE ${PARSE_RELATIVE} FILES ${PARSE_UNPARSED_ARGUMENTS})
+    
+    set(INTERNAL_EMBED_LIB embed_lib_${EMBED_NAME})
+    add_library(${INTERNAL_EMBED_LIB} OBJECT "${SRC_FILE}")
+    target_include_directories(${INTERNAL_EMBED_LIB} PRIVATE "${EMBED_DIR}/include")
+    target_compile_options(${INTERNAL_EMBED_LIB} PRIVATE -Wno-reserved-identifier -Wno-extern-initializer -Wno-missing-variable-declarations)
+    set_target_properties(${INTERNAL_EMBED_LIB} PROPERTIES POSITION_INDEPENDENT_CODE On)
+    
+    add_library(${EMBED_NAME} INTERFACE)
+    if(EMBED_USE_LD)
+        target_sources(${EMBED_NAME} INTERFACE ${OUTPUT_FILES})
+    else()
+        target_sources(${INTERNAL_EMBED_LIB} PRIVATE ${OUTPUT_FILES})
+    endif()
+    target_sources(${EMBED_NAME} INTERFACE $<TARGET_OBJECTS:${INTERNAL_EMBED_LIB}>)
+    target_include_directories(${EMBED_NAME} INTERFACE "${EMBED_DIR}/include")
 endfunction()

cmake/PythonModules.cmake

@@ -38,12 +38,22 @@ macro(find_python version)
     find_program(PYTHON_CONFIG_${version} python${version}-config)
     if(EXISTS ${PYTHON_CONFIG_${version}})
         py_exec(COMMAND ${PYTHON_CONFIG_${version}} --includes OUTPUT_VARIABLE _python_include_args)
+        execute_process(COMMAND ${PYTHON_CONFIG_${version}} --ldflags --embed OUTPUT_VARIABLE _python_ldflags_args RESULT_VARIABLE _python_ldflags_result)
+        if(NOT _python_ldflags_result EQUAL 0)
+            py_exec(COMMAND ${PYTHON_CONFIG_${version}} --ldflags OUTPUT_VARIABLE _python_ldflags_args)
+        endif()
         separate_arguments(_python_includes UNIX_COMMAND "${_python_include_args}")
+        separate_arguments(_python_ldflags UNIX_COMMAND "${_python_ldflags_args}")
         string(REPLACE "-I" "" _python_includes "${_python_includes}")
         add_library(python${version}::headers INTERFACE IMPORTED GLOBAL)
         set_target_properties(python${version}::headers PROPERTIES
             INTERFACE_INCLUDE_DIRECTORIES "${_python_includes}"
         )
+        add_library(python${version}::runtime INTERFACE IMPORTED GLOBAL)
+        set_target_properties(python${version}::runtime PROPERTIES
+            INTERFACE_LINK_OPTIONS "${_python_ldflags}"
+            INTERFACE_LINK_LIBRARIES python${version}::headers
+        )
         py_exec(COMMAND ${PYTHON_CONFIG_${version}} --prefix OUTPUT_VARIABLE _python_prefix)
         string(STRIP "${_python_prefix}" _python_prefix)
         set(PYTHON_${version}_EXECUTABLE "${_python_prefix}/bin/python${version}" CACHE PATH "")

docs/driver/read.rst

@@ -82,6 +82,10 @@ Print out program in text format.
 
 Print out program in binary format.
 
+.. option::  --py
+
+Print out program using python API.
+
 .. option::  --output, -o [std::string]
 
 Output to file.

hip-clang.docker

@@ -12,7 +12,6 @@ RUN sh -c 'echo deb [arch=amd64 trusted=yes] http://repo.radeon.com/rocm/apt/5.6
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --allow-unauthenticated \
     apt-utils \
     build-essential \
-    clang-format-10 \
     cmake \
     curl \
     doxygen \

requirements.txt

@@ -24,7 +24,7 @@
 google/protobuf@v3.11.0 -DCMAKE_POSITION_INDEPENDENT_CODE=On -X subdir -Dprotobuf_BUILD_TESTS=Off
 nlohmann/json@v3.8.0
 live-clones/blaze@v3.8 -X header -DHEADER_DIR=blaze -H sha256:d0ff011f47538285178908ea5f2cab46bb6a8f55b1edb6e03224a82dbc1a3212
-ROCmSoftwarePlatform/half@rocm-5.4.2
+ROCmSoftwarePlatform/half@rocm-5.6.0
 pybind/pybind11@d159a563383d10c821ba7b2a71905d1207db6de4 --build
 msgpack/msgpack-c@cpp-3.3.0 -DMSGPACK_BUILD_TESTS=Off
 sqlite3@3.17 -DCMAKE_POSITION_INDEPENDENT_CODE=On

src/CMakeLists.txt

@@ -133,6 +133,7 @@ register_migraphx_ops(
     cosh
     cos
     dequantizelinear
+    dimensions_of
     div
     dot
     elu

src/api/CMakeLists.txt

@@ -26,6 +26,7 @@ add_library(migraphx_c
     api.cpp
 )
 set_target_properties(migraphx_c PROPERTIES EXPORT_NAME c)
+migraphx_generate_export_header(migraphx_c DIRECTORY migraphx/api)
 
 # migraphx_c is stable API interface library. SO version of this should be 
 # bumped when binary compatibility is broken. 

src/api/api.cpp

@@ -44,7 +44,7 @@ namespace migraphx {
 
 static thread_local bool disable_exception_catch = false; // NOLINT
 
-extern "C" void migraphx_test_private_disable_exception_catch(bool b)
+extern "C" MIGRAPHX_C_EXPORT void migraphx_test_private_disable_exception_catch(bool b)
 {
     disable_exception_catch = b;
 }

src/api/include/migraphx/migraphx.h

@@ -26,6 +26,9 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+
+#include <migraphx/api/export.h>
+
 // Add new types here
 // clang-format off
 #define MIGRAPHX_SHAPE_VISIT_TYPES(m) \
@@ -166,430 +169,460 @@ typedef migraphx_status (*migraphx_experimental_custom_op_copy)(void** out, void
 
 typedef migraphx_status (*migraphx_experimental_custom_op_delete)(void* input);
 
-migraphx_status migraphx_optimals_destroy(migraphx_optimals_t optimals);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_optimals_destroy(migraphx_optimals_t optimals);
 
-migraphx_status migraphx_optimals_assign_to(migraphx_optimals_t output,
-                                            const_migraphx_optimals_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_optimals_assign_to(migraphx_optimals_t output,
+                                                              const_migraphx_optimals_t input);
 
-migraphx_status
-migraphx_optimals_create(migraphx_optimals_t* optimals, const size_t* ptr, size_t size);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_optimals_create(migraphx_optimals_t* optimals,
+                                                           const size_t* ptr,
+                                                           size_t size);
 
-migraphx_status migraphx_dynamic_dimension_destroy(migraphx_dynamic_dimension_t dynamic_dimension);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_dynamic_dimension_destroy(migraphx_dynamic_dimension_t dynamic_dimension);
 
-migraphx_status migraphx_dynamic_dimension_assign_to(migraphx_dynamic_dimension_t output,
-                                                     const_migraphx_dynamic_dimension_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_dynamic_dimension_assign_to(
+    migraphx_dynamic_dimension_t output, const_migraphx_dynamic_dimension_t input);
 
-migraphx_status migraphx_dynamic_dimension_create_min_max(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_dynamic_dimension_create_min_max(
     migraphx_dynamic_dimension_t* dynamic_dimension, size_t min, size_t max);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_dynamic_dimension_create_min_max_optimals(migraphx_dynamic_dimension_t* dynamic_dimension,
                                                    size_t min,
                                                    size_t max,
                                                    migraphx_optimals_t optimals);
 
-migraphx_status
-migraphx_dynamic_dimension_is_fixed(bool* out,
-                                    const_migraphx_dynamic_dimension_t dynamic_dimension);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_dynamic_dimension_is_fixed(
+    bool* out, const_migraphx_dynamic_dimension_t dynamic_dimension);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_dynamic_dimension_equal(bool* out,
                                  const_migraphx_dynamic_dimension_t dynamic_dimension,
                                  const_migraphx_dynamic_dimension_t x);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_dynamic_dimensions_destroy(migraphx_dynamic_dimensions_t dynamic_dimensions);
 
-migraphx_status migraphx_dynamic_dimensions_assign_to(migraphx_dynamic_dimensions_t output,
-                                                      const_migraphx_dynamic_dimensions_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_dynamic_dimensions_assign_to(
+    migraphx_dynamic_dimensions_t output, const_migraphx_dynamic_dimensions_t input);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_dynamic_dimensions_create(migraphx_dynamic_dimensions_t* dynamic_dimensions,
                                    const_migraphx_dynamic_dimension_t* ptr,
                                    size_t size);
 
-migraphx_status migraphx_dynamic_dimensions_size(size_t* out,
-                                                 migraphx_dynamic_dimensions_t dynamic_dimensions);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_dynamic_dimensions_size(size_t* out, migraphx_dynamic_dimensions_t dynamic_dimensions);
 
-migraphx_status migraphx_dynamic_dimensions_get(const_migraphx_dynamic_dimension_t* out,
-                                                migraphx_dynamic_dimensions_t dynamic_dimensions,
-                                                size_t idx);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_dynamic_dimensions_get(const_migraphx_dynamic_dimension_t* out,
+                                migraphx_dynamic_dimensions_t dynamic_dimensions,
+                                size_t idx);
 
-migraphx_status migraphx_shape_destroy(migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_destroy(migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_assign_to(migraphx_shape_t output, const_migraphx_shape_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_assign_to(migraphx_shape_t output,
+                                                           const_migraphx_shape_t input);
 
-migraphx_status migraphx_shape_create(migraphx_shape_t* shape,
-                                      migraphx_shape_datatype_t type,
-                                      size_t* lengths,
-                                      size_t lengths_size);
+MIGRAPHX_C_EXPORT 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_create_with_strides(migraphx_shape_t* shape,
-                                                   migraphx_shape_datatype_t type,
-                                                   size_t* lengths,
-                                                   size_t lengths_size,
-                                                   size_t* strides,
-                                                   size_t strides_size);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_create_with_strides(migraphx_shape_t* shape,
+                                                                     migraphx_shape_datatype_t type,
+                                                                     size_t* lengths,
+                                                                     size_t lengths_size,
+                                                                     size_t* strides,
+                                                                     size_t strides_size);
 
-migraphx_status migraphx_shape_create_scalar(migraphx_shape_t* shape,
-                                             migraphx_shape_datatype_t type);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_create_scalar(migraphx_shape_t* shape,
+                                                               migraphx_shape_datatype_t type);
 
-migraphx_status migraphx_shape_create_dynamic(migraphx_shape_t* shape,
-                                              migraphx_shape_datatype_t type,
-                                              migraphx_dynamic_dimensions_t dims);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_create_dynamic(migraphx_shape_t* shape,
+                                                                migraphx_shape_datatype_t type,
+                                                                migraphx_dynamic_dimensions_t dims);
 
-migraphx_status
-migraphx_shape_lengths(const size_t** out, size_t* out_size, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT 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_C_EXPORT migraphx_status migraphx_shape_strides(const size_t** out,
+                                                         size_t* out_size,
+                                                         const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_dyn_dims(migraphx_dynamic_dimensions_t* out,
-                                        const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_dyn_dims(migraphx_dynamic_dimensions_t* out,
+                                                          const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_type(migraphx_shape_datatype_t* out, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_type(migraphx_shape_datatype_t* out,
+                                                      const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_elements(size_t* out, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_elements(size_t* out,
+                                                          const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_bytes(size_t* out, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_bytes(size_t* out, const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_ndim(size_t* out, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_ndim(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_C_EXPORT migraphx_status migraphx_shape_equal(bool* out,
+                                                       const_migraphx_shape_t shape,
+                                                       const_migraphx_shape_t x);
 
-migraphx_status migraphx_shape_standard(bool* out, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_standard(bool* out, const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_dynamic(bool* out, const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_dynamic(bool* out, const_migraphx_shape_t shape);
 
-migraphx_status migraphx_shape_index(size_t* out, const_migraphx_shape_t shape, size_t i);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_index(size_t* out,
+                                                       const_migraphx_shape_t shape,
+                                                       size_t i);
 
-migraphx_status migraphx_argument_destroy(migraphx_argument_t argument);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_destroy(migraphx_argument_t argument);
 
-migraphx_status migraphx_argument_assign_to(migraphx_argument_t output,
-                                            const_migraphx_argument_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_assign_to(migraphx_argument_t output,
+                                                              const_migraphx_argument_t input);
 
-migraphx_status
-migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_create(migraphx_argument_t* argument,
+                                                           const_migraphx_shape_t shape,
+                                                           void* buffer);
 
-migraphx_status migraphx_argument_create_empty(migraphx_argument_t* argument,
-                                               const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_create_empty(migraphx_argument_t* argument,
+                                                                 const_migraphx_shape_t shape);
 
-migraphx_status migraphx_argument_shape(const_migraphx_shape_t* out,
-                                        const_migraphx_argument_t argument);
+MIGRAPHX_C_EXPORT 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_C_EXPORT 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_C_EXPORT 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_C_EXPORT 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_C_EXPORT migraphx_status migraphx_target_destroy(migraphx_target_t target);
 
-migraphx_status migraphx_target_assign_to(migraphx_target_t output, const_migraphx_target_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_target_assign_to(migraphx_target_t output,
+                                                            const_migraphx_target_t input);
 
-migraphx_status migraphx_target_create(migraphx_target_t* target, const char* name);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_target_create(migraphx_target_t* target,
+                                                         const char* name);
 
-migraphx_status migraphx_program_parameter_shapes_destroy(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_parameter_shapes_destroy(
     migraphx_program_parameter_shapes_t program_parameter_shapes);
 
-migraphx_status
-migraphx_program_parameter_shapes_assign_to(migraphx_program_parameter_shapes_t output,
-                                            const_migraphx_program_parameter_shapes_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_parameter_shapes_assign_to(
+    migraphx_program_parameter_shapes_t output, const_migraphx_program_parameter_shapes_t input);
 
-migraphx_status migraphx_program_parameter_shapes_size(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_parameter_shapes_size(
     size_t* out, migraphx_program_parameter_shapes_t program_parameter_shapes);
 
-migraphx_status
+MIGRAPHX_C_EXPORT 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(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_parameter_shapes_names(
     const char** out, migraphx_program_parameter_shapes_t program_parameter_shapes);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_program_parameters_destroy(migraphx_program_parameters_t program_parameters);
 
-migraphx_status migraphx_program_parameters_assign_to(migraphx_program_parameters_t output,
-                                                      const_migraphx_program_parameters_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_parameters_assign_to(
+    migraphx_program_parameters_t output, const_migraphx_program_parameters_t input);
 
-migraphx_status
+MIGRAPHX_C_EXPORT 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_C_EXPORT 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_C_EXPORT migraphx_status migraphx_arguments_destroy(migraphx_arguments_t arguments);
 
-migraphx_status migraphx_arguments_assign_to(migraphx_arguments_t output,
-                                             const_migraphx_arguments_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_arguments_assign_to(migraphx_arguments_t output,
+                                                               const_migraphx_arguments_t input);
 
-migraphx_status migraphx_arguments_size(size_t* out, migraphx_arguments_t arguments);
+MIGRAPHX_C_EXPORT 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_C_EXPORT 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_C_EXPORT migraphx_status migraphx_shapes_destroy(migraphx_shapes_t shapes);
 
-migraphx_status migraphx_shapes_assign_to(migraphx_shapes_t output, const_migraphx_shapes_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shapes_assign_to(migraphx_shapes_t output,
+                                                            const_migraphx_shapes_t input);
 
-migraphx_status migraphx_shapes_size(size_t* out, migraphx_shapes_t shapes);
+MIGRAPHX_C_EXPORT 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_C_EXPORT migraphx_status migraphx_shapes_get(const_migraphx_shape_t* out,
+                                                      migraphx_shapes_t shapes,
+                                                      size_t idx);
 
-migraphx_status migraphx_instruction_destroy(migraphx_instruction_t instruction);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_instruction_destroy(migraphx_instruction_t instruction);
 
-migraphx_status migraphx_instruction_assign_to(migraphx_instruction_t output,
-                                               const_migraphx_instruction_t input);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_instruction_assign_to(migraphx_instruction_t output, const_migraphx_instruction_t input);
 
-migraphx_status migraphx_instructions_destroy(migraphx_instructions_t instructions);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_instructions_destroy(migraphx_instructions_t instructions);
 
-migraphx_status migraphx_instructions_assign_to(migraphx_instructions_t output,
-                                                const_migraphx_instructions_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_instructions_assign_to(
+    migraphx_instructions_t output, const_migraphx_instructions_t input);
 
-migraphx_status migraphx_instructions_create(migraphx_instructions_t* instructions,
-                                             const_migraphx_instruction_t* ptr,
-                                             size_t size);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_instructions_create(
+    migraphx_instructions_t* instructions, const_migraphx_instruction_t* ptr, size_t size);
 
-migraphx_status migraphx_modules_destroy(migraphx_modules_t modules);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_modules_destroy(migraphx_modules_t modules);
 
-migraphx_status migraphx_modules_assign_to(migraphx_modules_t output,
-                                           const_migraphx_modules_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_modules_assign_to(migraphx_modules_t output,
+                                                             const_migraphx_modules_t input);
 
-migraphx_status
-migraphx_modules_create(migraphx_modules_t* modules, migraphx_module_t* ptr, size_t size);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_modules_create(migraphx_modules_t* modules,
+                                                          migraphx_module_t* ptr,
+                                                          size_t size);
 
-migraphx_status migraphx_module_create(migraphx_module_t* module, char* name);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_create(migraphx_module_t* module, char* name);
 
-migraphx_status migraphx_module_print(const_migraphx_module_t module);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_print(const_migraphx_module_t module);
 
-migraphx_status migraphx_module_add_instruction(migraphx_instruction_t* out,
-                                                migraphx_module_t module,
-                                                migraphx_operation_t op,
-                                                migraphx_instructions_t args);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_instruction(migraphx_instruction_t* out,
+                                                                  migraphx_module_t module,
+                                                                  migraphx_operation_t op,
+                                                                  migraphx_instructions_t args);
 
-migraphx_status migraphx_module_add_instruction_with_mod_args(migraphx_instruction_t* out,
-                                                              migraphx_module_t module,
-                                                              migraphx_operation_t op,
-                                                              migraphx_instructions_t args,
-                                                              migraphx_modules_t module_refs);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_module_add_instruction_with_mod_args(migraphx_instruction_t* out,
+                                              migraphx_module_t module,
+                                              migraphx_operation_t op,
+                                              migraphx_instructions_t args,
+                                              migraphx_modules_t module_refs);
 
-migraphx_status migraphx_module_add_literal(migraphx_instruction_t* out,
-                                            migraphx_module_t module,
-                                            const_migraphx_shape_t shape,
-                                            const char* buffer);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_literal(migraphx_instruction_t* out,
+                                                              migraphx_module_t module,
+                                                              const_migraphx_shape_t shape,
+                                                              const char* buffer);
 
-migraphx_status migraphx_module_add_parameter(migraphx_instruction_t* out,
-                                              migraphx_module_t module,
-                                              const char* name,
-                                              const_migraphx_shape_t shape);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_parameter(migraphx_instruction_t* out,
+                                                                migraphx_module_t module,
+                                                                const char* name,
+                                                                const_migraphx_shape_t shape);
 
-migraphx_status migraphx_module_add_return(migraphx_instruction_t* out,
-                                           migraphx_module_t module,
-                                           migraphx_instructions_t args);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_return(migraphx_instruction_t* out,
+                                                             migraphx_module_t module,
+                                                             migraphx_instructions_t args);
 
-migraphx_status migraphx_module_add_allocation(migraphx_instruction_t* out,
-                                               migraphx_module_t module,
-                                               const_migraphx_shape_t s);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_allocation(migraphx_instruction_t* out,
+                                                                 migraphx_module_t module,
+                                                                 const_migraphx_shape_t s);
 
-migraphx_status migraphx_program_destroy(migraphx_program_t program);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_destroy(migraphx_program_t program);
 
-migraphx_status migraphx_program_assign_to(migraphx_program_t output,
-                                           const_migraphx_program_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_assign_to(migraphx_program_t output,
+                                                             const_migraphx_program_t input);
 
-migraphx_status migraphx_program_create(migraphx_program_t* program);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_create(migraphx_program_t* program);
 
-migraphx_status migraphx_program_get_main_module(migraphx_module_t* out,
-                                                 migraphx_program_t program);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_get_main_module(migraphx_module_t* out,
+                                                                   migraphx_program_t program);
 
-migraphx_status migraphx_program_create_module(migraphx_module_t* out,
-                                               migraphx_program_t program,
-                                               const char* name);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_create_module(migraphx_module_t* out,
+                                                                 migraphx_program_t program,
+                                                                 const char* name);
 
-migraphx_status migraphx_program_compile(migraphx_program_t program,
-                                         migraphx_target_t target,
-                                         migraphx_compile_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_compile(migraphx_program_t program,
+                                                           migraphx_target_t target,
+                                                           migraphx_compile_options_t options);
 
-migraphx_status migraphx_program_get_parameter_shapes(migraphx_program_parameter_shapes_t* out,
-                                                      migraphx_program_t program);
+MIGRAPHX_C_EXPORT 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_C_EXPORT 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_C_EXPORT migraphx_status migraphx_program_print(const_migraphx_program_t program);
 
-migraphx_status migraphx_program_sort(migraphx_program_t program);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_sort(migraphx_program_t program);
 
-migraphx_status migraphx_program_run(migraphx_arguments_t* out,
-                                     migraphx_program_t program,
-                                     migraphx_program_parameters_t params);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_run(migraphx_arguments_t* out,
+                                                       migraphx_program_t program,
+                                                       migraphx_program_parameters_t params);
 
-migraphx_status migraphx_program_run_async(migraphx_arguments_t* out,
-                                           migraphx_program_t program,
-                                           migraphx_program_parameters_t params,
-                                           void* s,
-                                           const char* name);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_run_async(migraphx_arguments_t* out,
+                                                             migraphx_program_t program,
+                                                             migraphx_program_parameters_t params,
+                                                             void* s,
+                                                             const char* name);
 
-migraphx_status
-migraphx_program_equal(bool* out, const_migraphx_program_t program, const_migraphx_program_t x);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_equal(bool* out,
+                                                         const_migraphx_program_t program,
+                                                         const_migraphx_program_t x);
 
-migraphx_status migraphx_program_experimental_get_context(migraphx_context_t* out,
-                                                          const_migraphx_program_t program);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_experimental_get_context(
+    migraphx_context_t* out, const_migraphx_program_t program);
 
-migraphx_status migraphx_operation_destroy(migraphx_operation_t operation);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_operation_destroy(migraphx_operation_t operation);
 
-migraphx_status migraphx_operation_assign_to(migraphx_operation_t output,
-                                             const_migraphx_operation_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_operation_assign_to(migraphx_operation_t output,
+                                                               const_migraphx_operation_t input);
 
-migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
-                                          const char* name,
-                                          const char* attributes,
-                                          ...);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
+                                                            const char* name,
+                                                            const char* attributes,
+                                                            ...);
 
-migraphx_status migraphx_operation_name(char* out, size_t out_size, migraphx_operation_t operation);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_operation_name(char* out,
+                                                          size_t out_size,
+                                                          migraphx_operation_t operation);
 
-migraphx_status
-migraphx_load(migraphx_program_t* out, const char* name, migraphx_file_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_load(migraphx_program_t* out,
+                                                const char* name,
+                                                migraphx_file_options_t options);
 
-migraphx_status
-migraphx_save(migraphx_program_t p, const char* name, migraphx_file_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_save(migraphx_program_t p,
+                                                const char* name,
+                                                migraphx_file_options_t options);
 
-migraphx_status migraphx_onnx_options_destroy(migraphx_onnx_options_t onnx_options);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_onnx_options_destroy(migraphx_onnx_options_t onnx_options);
 
-migraphx_status migraphx_onnx_options_assign_to(migraphx_onnx_options_t output,
-                                                const_migraphx_onnx_options_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_assign_to(
+    migraphx_onnx_options_t output, const_migraphx_onnx_options_t input);
 
-migraphx_status migraphx_onnx_options_create(migraphx_onnx_options_t* onnx_options);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_onnx_options_create(migraphx_onnx_options_t* onnx_options);
 
-migraphx_status migraphx_onnx_options_set_input_parameter_shape(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_set_input_parameter_shape(
     migraphx_onnx_options_t onnx_options, const char* name, size_t* dims, size_t dims_size);
 
-migraphx_status migraphx_onnx_options_set_dyn_input_parameter_shape(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_set_dyn_input_parameter_shape(
     migraphx_onnx_options_t onnx_options, const char* name, migraphx_dynamic_dimensions_t dims);
 
-migraphx_status migraphx_onnx_options_set_default_dim_value(migraphx_onnx_options_t onnx_options,
-                                                            size_t value);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_onnx_options_set_default_dim_value(migraphx_onnx_options_t onnx_options, size_t value);
 
-migraphx_status
-migraphx_onnx_options_set_default_dyn_dim_value(migraphx_onnx_options_t onnx_options,
-                                                const_migraphx_dynamic_dimension_t dd);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_set_default_dyn_dim_value(
+    migraphx_onnx_options_t onnx_options, const_migraphx_dynamic_dimension_t dd);
 
-migraphx_status
-migraphx_onnx_options_set_default_loop_iterations(migraphx_onnx_options_t onnx_options,
-                                                  int64_t value);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_set_default_loop_iterations(
+    migraphx_onnx_options_t onnx_options, int64_t value);
 
-migraphx_status migraphx_file_options_destroy(migraphx_file_options_t file_options);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_file_options_destroy(migraphx_file_options_t file_options);
 
-migraphx_status migraphx_file_options_assign_to(migraphx_file_options_t output,
-                                                const_migraphx_file_options_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_file_options_assign_to(
+    migraphx_file_options_t output, const_migraphx_file_options_t input);
 
-migraphx_status migraphx_file_options_create(migraphx_file_options_t* file_options);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_file_options_create(migraphx_file_options_t* file_options);
 
-migraphx_status migraphx_file_options_set_file_format(migraphx_file_options_t file_options,
-                                                      const char* format);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_file_options_set_file_format(migraphx_file_options_t file_options, const char* format);
 
-migraphx_status migraphx_compile_options_destroy(migraphx_compile_options_t compile_options);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_compile_options_destroy(migraphx_compile_options_t compile_options);
 
-migraphx_status migraphx_compile_options_assign_to(migraphx_compile_options_t output,
-                                                   const_migraphx_compile_options_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_compile_options_assign_to(
+    migraphx_compile_options_t output, const_migraphx_compile_options_t input);
 
-migraphx_status migraphx_compile_options_create(migraphx_compile_options_t* compile_options);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_compile_options_create(migraphx_compile_options_t* compile_options);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_compile_options_set_offload_copy(migraphx_compile_options_t compile_options, bool value);
 
-migraphx_status migraphx_compile_options_set_fast_math(migraphx_compile_options_t compile_options,
-                                                       bool value);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_compile_options_set_fast_math(migraphx_compile_options_t compile_options, bool value);
 
-migraphx_status
-migraphx_compile_options_set_exhaustive_tune_flag(migraphx_compile_options_t compile_options,
-                                                  bool value);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_compile_options_set_exhaustive_tune_flag(
+    migraphx_compile_options_t compile_options, bool value);
 
-migraphx_status
-migraphx_parse_onnx(migraphx_program_t* out, const char* name, migraphx_onnx_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_parse_onnx(migraphx_program_t* out,
+                                                      const char* name,
+                                                      migraphx_onnx_options_t options);
 
-migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
-                                           const void* data,
-                                           size_t size,
-                                           migraphx_onnx_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
+                                                             const void* data,
+                                                             size_t size,
+                                                             migraphx_onnx_options_t options);
 
-migraphx_status migraphx_tf_options_destroy(migraphx_tf_options_t tf_options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_destroy(migraphx_tf_options_t tf_options);
 
-migraphx_status migraphx_tf_options_assign_to(migraphx_tf_options_t output,
-                                              const_migraphx_tf_options_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_assign_to(migraphx_tf_options_t output,
+                                                                const_migraphx_tf_options_t input);
 
-migraphx_status migraphx_tf_options_create(migraphx_tf_options_t* tf_options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_create(migraphx_tf_options_t* tf_options);
 
-migraphx_status migraphx_tf_options_set_nhwc(migraphx_tf_options_t tf_options, bool is_nhwc);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_set_nhwc(migraphx_tf_options_t tf_options,
+                                                               bool is_nhwc);
 
-migraphx_status migraphx_tf_options_set_input_parameter_shape(migraphx_tf_options_t tf_options,
-                                                              const char* name,
-                                                              size_t* dims,
-                                                              size_t dims_size);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_set_input_parameter_shape(
+    migraphx_tf_options_t tf_options, const char* name, size_t* dims, size_t dims_size);
 
-migraphx_status migraphx_tf_options_set_default_dim_value(migraphx_tf_options_t tf_options,
-                                                          size_t value);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_tf_options_set_default_dim_value(migraphx_tf_options_t tf_options, size_t value);
 
-migraphx_status migraphx_tf_options_set_output_names(migraphx_tf_options_t tf_options,
-                                                     const char** names,
-                                                     size_t names_size);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_set_output_names(
+    migraphx_tf_options_t tf_options, const char** names, size_t names_size);
 
-migraphx_status
-migraphx_parse_tf(migraphx_program_t* out, const char* name, migraphx_tf_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_parse_tf(migraphx_program_t* out,
+                                                    const char* name,
+                                                    migraphx_tf_options_t options);
 
-migraphx_status migraphx_quantize_op_names_destroy(migraphx_quantize_op_names_t quantize_op_names);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_quantize_op_names_destroy(migraphx_quantize_op_names_t quantize_op_names);
 
-migraphx_status migraphx_quantize_op_names_assign_to(migraphx_quantize_op_names_t output,
-                                                     const_migraphx_quantize_op_names_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_op_names_assign_to(
+    migraphx_quantize_op_names_t output, const_migraphx_quantize_op_names_t input);
 
-migraphx_status migraphx_quantize_op_names_create(migraphx_quantize_op_names_t* quantize_op_names);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_quantize_op_names_create(migraphx_quantize_op_names_t* quantize_op_names);
 
-migraphx_status migraphx_quantize_op_names_add(migraphx_quantize_op_names_t quantize_op_names,
-                                               const char* name);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_quantize_op_names_add(migraphx_quantize_op_names_t quantize_op_names, const char* name);
 
-migraphx_status migraphx_quantize_fp16_with_op_names(migraphx_program_t prog,
-                                                     migraphx_quantize_op_names_t name);
+MIGRAPHX_C_EXPORT migraphx_status
+migraphx_quantize_fp16_with_op_names(migraphx_program_t prog, migraphx_quantize_op_names_t name);
 
-migraphx_status migraphx_quantize_fp16(migraphx_program_t prog);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_fp16(migraphx_program_t prog);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_quantize_int8_options_destroy(migraphx_quantize_int8_options_t quantize_int8_options);
 
-migraphx_status
-migraphx_quantize_int8_options_assign_to(migraphx_quantize_int8_options_t output,
-                                         const_migraphx_quantize_int8_options_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_int8_options_assign_to(
+    migraphx_quantize_int8_options_t output, const_migraphx_quantize_int8_options_t input);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_quantize_int8_options_create(migraphx_quantize_int8_options_t* quantize_int8_options);
 
-migraphx_status
-migraphx_quantize_int8_options_add_op_name(migraphx_quantize_int8_options_t quantize_int8_options,
-                                           const char* name);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_int8_options_add_op_name(
+    migraphx_quantize_int8_options_t quantize_int8_options, const char* name);
 
-migraphx_status migraphx_quantize_int8_options_add_calibration_data(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_int8_options_add_calibration_data(
     migraphx_quantize_int8_options_t quantize_int8_options, migraphx_program_parameters_t data);
 
-migraphx_status migraphx_quantize_int8(migraphx_program_t prog,
-                                       migraphx_target_t target,
-                                       migraphx_quantize_int8_options_t options);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_int8(migraphx_program_t prog,
+                                                         migraphx_target_t target,
+                                                         migraphx_quantize_int8_options_t options);
 
-migraphx_status migraphx_context_finish(const_migraphx_context_t context);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_context_finish(const_migraphx_context_t context);
 
-migraphx_status migraphx_context_get_queue(void** out, migraphx_context_t context);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_context_get_queue(void** out,
+                                                             migraphx_context_t context);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_experimental_custom_op_destroy(migraphx_experimental_custom_op_t experimental_custom_op);
 
-migraphx_status
-migraphx_experimental_custom_op_assign_to(migraphx_experimental_custom_op_t output,
-                                          const_migraphx_experimental_custom_op_t input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_experimental_custom_op_assign_to(
+    migraphx_experimental_custom_op_t output, const_migraphx_experimental_custom_op_t input);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_experimental_custom_op_create(migraphx_experimental_custom_op_t* experimental_custom_op,
                                        void* obj,
                                        migraphx_experimental_custom_op_copy c,
@@ -597,21 +630,20 @@ migraphx_experimental_custom_op_create(migraphx_experimental_custom_op_t* experi
                                        const char* obj_typename,
                                        const char* name);
 
-migraphx_status
-migraphx_experimental_custom_op_set_compute(migraphx_experimental_custom_op_t obj,
-                                            migraphx_experimental_custom_op_compute input);
+MIGRAPHX_C_EXPORT migraphx_status migraphx_experimental_custom_op_set_compute(
+    migraphx_experimental_custom_op_t obj, migraphx_experimental_custom_op_compute input);
 
-migraphx_status migraphx_experimental_custom_op_set_compute_shape(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_experimental_custom_op_set_compute_shape(
     migraphx_experimental_custom_op_t obj, migraphx_experimental_custom_op_compute_shape input);
 
-migraphx_status migraphx_experimental_custom_op_set_output_alias(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_experimental_custom_op_set_output_alias(
     migraphx_experimental_custom_op_t obj, migraphx_experimental_custom_op_output_alias input);
 
-migraphx_status migraphx_experimental_custom_op_set_runs_on_offload_target(
+MIGRAPHX_C_EXPORT migraphx_status migraphx_experimental_custom_op_set_runs_on_offload_target(
     migraphx_experimental_custom_op_t obj,
     migraphx_experimental_custom_op_runs_on_offload_target input);
 
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status
 migraphx_experimental_custom_op_register(migraphx_experimental_custom_op_t experimental_custom_op);
 
 #ifdef __cplusplus

src/common.cpp

@@ -150,8 +150,8 @@ insert_common_args(module& m, instruction_ref ins, std::vector<instruction_ref>
         auto c_type       = compute_common_types(input_shapes);
         auto c_dyn_dims   = compute_common_dyn_dims(input_shapes);
 
-        // following should work for a static or dynamic shape
-        if(inputs[0]->get_shape().dyn_dims() != c_dyn_dims)
+        auto s0 = inputs[0]->get_shape();
+        if(not s0.dynamic() or s0.dyn_dims() != c_dyn_dims)
         {
             inputs[0] = m.insert_instruction(
                 ins, make_op("multibroadcast", {{"out_dyn_dims", to_value(c_dyn_dims)}}), inputs);
@@ -159,7 +159,8 @@ insert_common_args(module& m, instruction_ref ins, std::vector<instruction_ref>
         std::transform(inputs.begin() + 1, inputs.end(), inputs.begin() + 1, [&](auto input) {
             // uses previous input to avoid recalculating the common shape from the
             // full set of input shapes at runtime
-            if(input->get_shape().dyn_dims() != c_dyn_dims)
+            auto s = input->get_shape();
+            if(not s.dynamic() or s.dyn_dims() != c_dyn_dims)
             {
                 return m.insert_instruction(
                     ins,

src/driver/CMakeLists.txt

@@ -32,18 +32,20 @@ add_executable(driver
     marker_roctx.cpp
 )
 set_target_properties(driver PROPERTIES OUTPUT_NAME migraphx-driver)
-# Copy driver for backwards compatibility
-add_custom_command(
-        TARGET driver 
+if(NOT WIN32)
+    # Copy driver for backwards compatibility (Linux only)
+    add_custom_command(
+        TARGET driver
         POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy
                 $<TARGET_FILE:driver>
                 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/driver
         BYPRODUCTS ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/driver
-)
-set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/driver)
+    )
+    set_directory_properties(PROPERTIES ADDITIONAL_CLEAN_FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/driver)
+endif()
 rocm_clang_tidy_check(driver)
 
-target_link_libraries(driver migraphx_all_targets migraphx_onnx migraphx_tf)
+target_link_libraries(driver migraphx_all_targets migraphx_onnx migraphx_tf migraphx_py)
 
 # For ASAN Enabled Build no need to package binaries
 if( NOT ENABLE_ASAN_PACKAGING ) 

src/driver/main.cpp

@@ -32,6 +32,7 @@
 
 #include <migraphx/tf.hpp>
 #include <migraphx/onnx.hpp>
+#include <migraphx/py.hpp>
 #include <migraphx/stringutils.hpp>
 #include <migraphx/convert_to_json.hpp>
 #include <migraphx/load_save.hpp>
@@ -241,6 +242,20 @@ struct loader
         return options;
     }
 
+    static std::string get_file_type(const std::string& file)
+    {
+        if(ends_with(file, ".onnx"))
+            return "onnx";
+        else if(ends_with(file, ".pb"))
+            return "tf";
+        else if(ends_with(file, ".json"))
+            return "json";
+        else if(ends_with(file, ".py"))
+            return "py";
+        else
+            return "migraphx";
+    }
+
     program load()
     {
         program p;
@@ -248,14 +263,7 @@ struct loader
         {
             if(file_type.empty())
             {
-                if(ends_with(file, ".onnx"))
-                    file_type = "onnx";
-                else if(ends_with(file, ".pb"))
-                    file_type = "tf";
-                else if(ends_with(file, ".json"))
-                    file_type = "json";
-                else
-                    file_type = "migraphx";
+                file_type = get_file_type(file);
             }
             std::cout << "Reading: " << file << std::endl;
             if(file_type == "onnx")
@@ -272,6 +280,10 @@ struct loader
                 options.format = "json";
                 p              = migraphx::load(file, options);
             }
+            else if(file_type == "py")
+            {
+                p = migraphx::load_py(file);
+            }
             else if(file_type == "migraphx")
             {
                 p = migraphx::load(file);

src/dynamic_loader.cpp

@@ -48,7 +48,7 @@ struct dynamic_loader_impl
 #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif
     dynamic_loader_impl(const fs::path& p, std::shared_ptr<tmp_dir> t = nullptr)
-        : handle(dlopen(p.string().c_str(), RTLD_LAZY),
+        : handle(dlopen(p.string().c_str(), RTLD_GLOBAL | RTLD_NOW),
                  manage_deleter<decltype(&dlclose), &dlclose>{}),
           temp(std::move(t))
     {
@@ -81,6 +81,18 @@ fs::path dynamic_loader::path(void* address)
     return p;
 }
 
+optional<dynamic_loader> dynamic_loader::try_load(const fs::path& p)
+{
+    try
+    {
+        return dynamic_loader{p};
+    }
+    catch(const std::exception&)
+    {
+        return nullopt;
+    }
+}
+
 dynamic_loader::dynamic_loader(const fs::path& p) : impl(std::make_shared<dynamic_loader_impl>(p))
 {
 }

src/generate.cpp

@@ -26,7 +26,7 @@
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
-argument fill_argument(shape s, unsigned long value)
+argument fill_argument(shape s, double value)
 {
     argument result;
     if(s.type() == shape::tuple_type)