Merge branch 'develop' into rand_uniform

36bb977b · Brian Pickrell · d626a09e · c65ab678 · 36bb977b · 36bb977b
Commit 36bb977b authored Aug 07, 2023 by Brian Pickrell
20 changed files
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,6 +51,7 @@ project(migraphx LANGUAGES C CXX)
 include(CTest)
 find_package(ROCM REQUIRED)
+find_package(Threads REQUIRED)
 find_path(HALF_INCLUDE_DIR half.hpp PATH_SUFFIXES half)
 if (NOT HALF_INCLUDE_DIR)

--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -26,7 +26,7 @@ def rocmtestnode(Map conf) {
            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

--- a/cmake/Embed.cmake
+++ b/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" OFF)
-    option(EMBED_USE_LD "Use ld to embed data files" ON)
-else()
-    option(EMBED_USE_LD "Use ld to embed data files" OFF)
-endif()
 function(wrap_string)
    set(options)
@@ -60,8 +56,8 @@ endfunction()
 function(generate_embed_source EMBED_NAME)
    set(options)
-    set(oneValueArgs SRC HEADER)
+    set(oneValueArgs SRC HEADER RELATIVE)
-    set(multiValueArgs OBJECTS SYMBOLS)
+    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
+        if(PARSE_RELATIVE)
-        get_filename_component(BASE_NAME "${OBJECT}" NAME)
+            file(RELATIVE_PATH BASE_NAME ${PARSE_RELATIVE} "${FILE}")
-        string(REGEX REPLACE ".[A-Za-z0-9_]+$" "" BASE_NAME ${BASE_NAME})
+        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})
+    generate_embed_source(${EMBED_NAME} SRC ${SRC_FILE} HEADER ${HEADER_FILE} OBJECTS ${OUTPUT_FILES} SYMBOLS ${SYMBOLS} RELATIVE ${PARSE_RELATIVE} FILES ${PARSE_UNPARSED_ARGUMENTS})
-    add_library(${EMBED_NAME} STATIC ${OUTPUT_FILES} "${SRC_FILE}")
-    target_include_directories(${EMBED_NAME} PUBLIC "${EMBED_DIR}/include")
+    set(INTERNAL_EMBED_LIB embed_lib_${EMBED_NAME})
-    target_compile_options(${EMBED_NAME} PRIVATE -Wno-reserved-identifier -Wno-extern-initializer -Wno-missing-variable-declarations)
+    add_library(${INTERNAL_EMBED_LIB} OBJECT "${SRC_FILE}")
-    set_target_properties(${EMBED_NAME} PROPERTIES POSITION_INDEPENDENT_CODE On)
+    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()
--- a/cmake/PythonModules.cmake
+++ b/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 "")

--- a/docs/driver/read.rst
+++ b/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.

--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -249,8 +249,6 @@ endif()
 target_link_libraries(migraphx PRIVATE -ldl)
 target_include_directories(migraphx SYSTEM PUBLIC $<BUILD_INTERFACE:${HALF_INCLUDE_DIR}>)
-find_package(Threads)
 target_link_libraries(migraphx PUBLIC Threads::Threads)
 find_package(nlohmann_json 3.8.0 REQUIRED)

--- a/src/api/CMakeLists.txt
+++ b/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. 

--- a/src/api/api.cpp
+++ b/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;
 }

--- a/src/api/include/migraphx/migraphx.h
+++ 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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_optimals_assign_to(migraphx_optimals_t output,
-                                            const_migraphx_optimals_t input);
+                                                              const_migraphx_optimals_t input);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_optimals_create(migraphx_optimals_t* optimals,
-migraphx_optimals_create(migraphx_optimals_t* optimals, const size_t* ptr, size_t size);
+                                                           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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_dynamic_dimension_assign_to(
-                                                     const_migraphx_dynamic_dimension_t input);
+    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_C_EXPORT migraphx_status migraphx_dynamic_dimension_is_fixed(
-migraphx_dynamic_dimension_is_fixed(bool* out,
+    bool* out, const_migraphx_dynamic_dimension_t dynamic_dimension);
-                                    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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_dynamic_dimensions_assign_to(
-                                                      const_migraphx_dynamic_dimensions_t input);
+    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_C_EXPORT migraphx_status
-                                                 migraphx_dynamic_dimensions_t dynamic_dimensions);
+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_C_EXPORT migraphx_status
-                                                migraphx_dynamic_dimensions_t dynamic_dimensions,
+migraphx_dynamic_dimensions_get(const_migraphx_dynamic_dimension_t* out,
-                                                size_t idx);
+                                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_C_EXPORT migraphx_status migraphx_shape_create(migraphx_shape_t* shape,
-                                      migraphx_shape_datatype_t type,
+                                                        migraphx_shape_datatype_t type,
-                                      size_t* lengths,
+                                                        size_t* lengths,
-                                      size_t lengths_size);
+                                                        size_t lengths_size);
-migraphx_status migraphx_shape_create_with_strides(migraphx_shape_t* shape,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_create_with_strides(migraphx_shape_t* shape,
-                                                   migraphx_shape_datatype_t type,
+                                                                     migraphx_shape_datatype_t type,
-                                                   size_t* lengths,
+                                                                     size_t* lengths,
-                                                   size_t lengths_size,
+                                                                     size_t lengths_size,
-                                                   size_t* strides,
+                                                                     size_t* strides,
-                                                   size_t strides_size);
+                                                                     size_t strides_size);
-migraphx_status migraphx_shape_create_scalar(migraphx_shape_t* shape,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_create_scalar(migraphx_shape_t* shape,
-                                             migraphx_shape_datatype_t type);
+                                                               migraphx_shape_datatype_t type);
-migraphx_status migraphx_shape_create_dynamic(migraphx_shape_t* shape,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_create_dynamic(migraphx_shape_t* shape,
-                                              migraphx_shape_datatype_t type,
+                                                                migraphx_shape_datatype_t type,
-                                              migraphx_dynamic_dimensions_t dims);
+                                                                migraphx_dynamic_dimensions_t dims);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_lengths(const size_t** out,
-migraphx_shape_lengths(const size_t** out, size_t* out_size, const_migraphx_shape_t shape);
+                                                         size_t* out_size,
+                                                         const_migraphx_shape_t shape);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_strides(const size_t** out,
-migraphx_shape_strides(const size_t** out, size_t* out_size, const_migraphx_shape_t shape);
+                                                         size_t* out_size,
+                                                         const_migraphx_shape_t shape);
-migraphx_status migraphx_shape_dyn_dims(migraphx_dynamic_dimensions_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_shape_dyn_dims(migraphx_dynamic_dimensions_t* out,
-                                        const_migraphx_shape_t shape);
+                                                          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_C_EXPORT migraphx_status migraphx_shape_equal(bool* out,
-migraphx_shape_equal(bool* out, const_migraphx_shape_t shape, const_migraphx_shape_t x);
+                                                       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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_assign_to(migraphx_argument_t output,
-                                            const_migraphx_argument_t input);
+                                                              const_migraphx_argument_t input);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_create(migraphx_argument_t* argument,
-migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer);
+                                                           const_migraphx_shape_t shape,
+                                                           void* buffer);
-migraphx_status migraphx_argument_create_empty(migraphx_argument_t* argument,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_create_empty(migraphx_argument_t* argument,
-                                               const_migraphx_shape_t shape);
+                                                                 const_migraphx_shape_t shape);
-migraphx_status migraphx_argument_shape(const_migraphx_shape_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_shape(const_migraphx_shape_t* out,
-                                        const_migraphx_argument_t argument);
+                                                          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_C_EXPORT migraphx_status migraphx_argument_equal(bool* out,
-migraphx_argument_equal(bool* out, const_migraphx_argument_t argument, const_migraphx_argument_t x);
+                                                          const_migraphx_argument_t argument,
+                                                          const_migraphx_argument_t x);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_argument_generate(migraphx_argument_t* out,
-migraphx_argument_generate(migraphx_argument_t* out, const_migraphx_shape_t s, size_t seed);
+                                                             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_C_EXPORT migraphx_status migraphx_program_parameter_shapes_assign_to(
-migraphx_program_parameter_shapes_assign_to(migraphx_program_parameter_shapes_t output,
+    migraphx_program_parameter_shapes_t output, const_migraphx_program_parameter_shapes_t input);
-                                            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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_parameters_assign_to(
-                                                      const_migraphx_program_parameters_t input);
+    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,
+MIGRAPHX_C_EXPORT migraphx_status
-                                                const char* name,
+migraphx_program_parameters_add(migraphx_program_parameters_t program_parameters,
-                                                const_migraphx_argument_t argument);
+                                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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_arguments_assign_to(migraphx_arguments_t output,
-                                             const_migraphx_arguments_t input);
+                                                               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_C_EXPORT migraphx_status migraphx_arguments_get(const_migraphx_argument_t* out,
-migraphx_arguments_get(const_migraphx_argument_t* out, migraphx_arguments_t arguments, size_t idx);
+                                                         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_C_EXPORT migraphx_status migraphx_shapes_get(const_migraphx_shape_t* out,
-migraphx_shapes_get(const_migraphx_shape_t* out, migraphx_shapes_t shapes, size_t idx);
+                                                      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,
+MIGRAPHX_C_EXPORT migraphx_status
-                                               const_migraphx_instruction_t input);
+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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_instructions_assign_to(
-                                                const_migraphx_instructions_t input);
+    migraphx_instructions_t output, const_migraphx_instructions_t input);
-migraphx_status migraphx_instructions_create(migraphx_instructions_t* instructions,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_instructions_create(
-                                             const_migraphx_instruction_t* ptr,
+    migraphx_instructions_t* instructions, const_migraphx_instruction_t* ptr, size_t size);
-                                             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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_modules_assign_to(migraphx_modules_t output,
-                                           const_migraphx_modules_t input);
+                                                             const_migraphx_modules_t input);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_modules_create(migraphx_modules_t* modules,
-migraphx_modules_create(migraphx_modules_t* modules, migraphx_module_t* ptr, size_t size);
+                                                          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_C_EXPORT migraphx_status migraphx_module_add_instruction(migraphx_instruction_t* out,
-                                                migraphx_module_t module,
+                                                                  migraphx_module_t module,
-                                                migraphx_operation_t op,
+                                                                  migraphx_operation_t op,
-                                                migraphx_instructions_t args);
+                                                                  migraphx_instructions_t args);
-migraphx_status migraphx_module_add_instruction_with_mod_args(migraphx_instruction_t* out,
+MIGRAPHX_C_EXPORT migraphx_status
-                                                              migraphx_module_t module,
+migraphx_module_add_instruction_with_mod_args(migraphx_instruction_t* out,
-                                                              migraphx_operation_t op,
+                                              migraphx_module_t module,
-                                                              migraphx_instructions_t args,
+                                              migraphx_operation_t op,
-                                                              migraphx_modules_t module_refs);
+                                              migraphx_instructions_t args,
+                                              migraphx_modules_t module_refs);
-migraphx_status migraphx_module_add_literal(migraphx_instruction_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_literal(migraphx_instruction_t* out,
-                                            migraphx_module_t module,
+                                                              migraphx_module_t module,
-                                            const_migraphx_shape_t shape,
+                                                              const_migraphx_shape_t shape,
-                                            const char* buffer);
+                                                              const char* buffer);
-migraphx_status migraphx_module_add_parameter(migraphx_instruction_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_parameter(migraphx_instruction_t* out,
-                                              migraphx_module_t module,
+                                                                migraphx_module_t module,
-                                              const char* name,
+                                                                const char* name,
-                                              const_migraphx_shape_t shape);
+                                                                const_migraphx_shape_t shape);
-migraphx_status migraphx_module_add_return(migraphx_instruction_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_return(migraphx_instruction_t* out,
-                                           migraphx_module_t module,
+                                                             migraphx_module_t module,
-                                           migraphx_instructions_t args);
+                                                             migraphx_instructions_t args);
-migraphx_status migraphx_module_add_allocation(migraphx_instruction_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_module_add_allocation(migraphx_instruction_t* out,
-                                               migraphx_module_t module,
+                                                                 migraphx_module_t module,
-                                               const_migraphx_shape_t s);
+                                                                 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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_assign_to(migraphx_program_t output,
-                                           const_migraphx_program_t input);
+                                                             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_C_EXPORT migraphx_status migraphx_program_get_main_module(migraphx_module_t* out,
-                                                 migraphx_program_t program);
+                                                                   migraphx_program_t program);
-migraphx_status migraphx_program_create_module(migraphx_module_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_create_module(migraphx_module_t* out,
-                                               migraphx_program_t program,
+                                                                 migraphx_program_t program,
-                                               const char* name);
+                                                                 const char* name);
-migraphx_status migraphx_program_compile(migraphx_program_t program,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_compile(migraphx_program_t program,
-                                         migraphx_target_t target,
+                                                           migraphx_target_t target,
-                                         migraphx_compile_options_t options);
+                                                           migraphx_compile_options_t options);
-migraphx_status migraphx_program_get_parameter_shapes(migraphx_program_parameter_shapes_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_get_parameter_shapes(
-                                                      migraphx_program_t program);
+    migraphx_program_parameter_shapes_t* out, migraphx_program_t program);
-migraphx_status migraphx_program_get_output_shapes(migraphx_shapes_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_get_output_shapes(migraphx_shapes_t* out,
-                                                   migraphx_program_t program);
+                                                                     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_C_EXPORT migraphx_status migraphx_program_run(migraphx_arguments_t* out,
-                                     migraphx_program_t program,
+                                                       migraphx_program_t program,
-                                     migraphx_program_parameters_t params);
+                                                       migraphx_program_parameters_t params);
-migraphx_status migraphx_program_run_async(migraphx_arguments_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_run_async(migraphx_arguments_t* out,
-                                           migraphx_program_t program,
+                                                             migraphx_program_t program,
-                                           migraphx_program_parameters_t params,
+                                                             migraphx_program_parameters_t params,
-                                           void* s,
+                                                             void* s,
-                                           const char* name);
+                                                             const char* name);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_equal(bool* out,
-migraphx_program_equal(bool* out, const_migraphx_program_t program, const_migraphx_program_t x);
+                                                         const_migraphx_program_t program,
+                                                         const_migraphx_program_t x);
-migraphx_status migraphx_program_experimental_get_context(migraphx_context_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_program_experimental_get_context(
-                                                          const_migraphx_program_t program);
+    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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_operation_assign_to(migraphx_operation_t output,
-                                             const_migraphx_operation_t input);
+                                                               const_migraphx_operation_t input);
-migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
-                                          const char* name,
+                                                            const char* name,
-                                          const char* attributes,
+                                                            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_C_EXPORT migraphx_status migraphx_load(migraphx_program_t* out,
-migraphx_load(migraphx_program_t* out, const char* name, migraphx_file_options_t options);
+                                                const char* name,
+                                                migraphx_file_options_t options);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_save(migraphx_program_t p,
-migraphx_save(migraphx_program_t p, const char* name, migraphx_file_options_t options);
+                                                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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_assign_to(
-                                                const_migraphx_onnx_options_t input);
+    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,
+MIGRAPHX_C_EXPORT migraphx_status
-                                                            size_t value);
+migraphx_onnx_options_set_default_dim_value(migraphx_onnx_options_t onnx_options, size_t value);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_set_default_dyn_dim_value(
-migraphx_onnx_options_set_default_dyn_dim_value(migraphx_onnx_options_t onnx_options,
+    migraphx_onnx_options_t onnx_options, const_migraphx_dynamic_dimension_t dd);
-                                                const_migraphx_dynamic_dimension_t dd);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_onnx_options_set_default_loop_iterations(
-migraphx_onnx_options_set_default_loop_iterations(migraphx_onnx_options_t onnx_options,
+    migraphx_onnx_options_t onnx_options, int64_t value);
-                                                  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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_file_options_assign_to(
-                                                const_migraphx_file_options_t input);
+    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,
+MIGRAPHX_C_EXPORT migraphx_status
-                                                      const char* format);
+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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_compile_options_assign_to(
-                                                   const_migraphx_compile_options_t input);
+    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,
+MIGRAPHX_C_EXPORT migraphx_status
-                                                       bool value);
+migraphx_compile_options_set_fast_math(migraphx_compile_options_t compile_options, bool value);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_compile_options_set_exhaustive_tune_flag(
-migraphx_compile_options_set_exhaustive_tune_flag(migraphx_compile_options_t compile_options,
+    migraphx_compile_options_t compile_options, bool value);
-                                                  bool value);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_parse_onnx(migraphx_program_t* out,
-migraphx_parse_onnx(migraphx_program_t* out, const char* name, migraphx_onnx_options_t options);
+                                                      const char* name,
+                                                      migraphx_onnx_options_t options);
-migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
-                                           const void* data,
+                                                             const void* data,
-                                           size_t size,
+                                                             size_t size,
-                                           migraphx_onnx_options_t options);
+                                                             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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_assign_to(migraphx_tf_options_t output,
-                                              const_migraphx_tf_options_t input);
+                                                                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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_set_input_parameter_shape(
-                                                              const char* name,
+    migraphx_tf_options_t tf_options, const char* name, size_t* dims, size_t dims_size);
-                                                              size_t* dims,
-                                                              size_t dims_size);
-migraphx_status migraphx_tf_options_set_default_dim_value(migraphx_tf_options_t tf_options,
+MIGRAPHX_C_EXPORT migraphx_status
-                                                          size_t value);
+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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_tf_options_set_output_names(
-                                                     const char** names,
+    migraphx_tf_options_t tf_options, const char** names, size_t names_size);
-                                                     size_t names_size);
-migraphx_status
+MIGRAPHX_C_EXPORT migraphx_status migraphx_parse_tf(migraphx_program_t* out,
-migraphx_parse_tf(migraphx_program_t* out, const char* name, migraphx_tf_options_t options);
+                                                    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,
+MIGRAPHX_C_EXPORT migraphx_status migraphx_quantize_op_names_assign_to(
-                                                     const_migraphx_quantize_op_names_t input);
+    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,
+MIGRAPHX_C_EXPORT migraphx_status
-                                               const char* name);
+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_C_EXPORT migraphx_status
-                                                     migraphx_quantize_op_names_t name);
+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_C_EXPORT migraphx_status migraphx_quantize_int8_options_assign_to(
-migraphx_quantize_int8_options_assign_to(migraphx_quantize_int8_options_t output,
+    migraphx_quantize_int8_options_t output, const_migraphx_quantize_int8_options_t input);
-                                         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_C_EXPORT migraphx_status migraphx_quantize_int8_options_add_op_name(
-migraphx_quantize_int8_options_add_op_name(migraphx_quantize_int8_options_t quantize_int8_options,
+    migraphx_quantize_int8_options_t quantize_int8_options, const char* name);
-                                           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_C_EXPORT migraphx_status migraphx_quantize_int8(migraphx_program_t prog,
-                                       migraphx_target_t target,
+                                                         migraphx_target_t target,
-                                       migraphx_quantize_int8_options_t options);
+                                                         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_C_EXPORT migraphx_status migraphx_experimental_custom_op_assign_to(
-migraphx_experimental_custom_op_assign_to(migraphx_experimental_custom_op_t output,
+    migraphx_experimental_custom_op_t output, const_migraphx_experimental_custom_op_t input);
-                                          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_C_EXPORT migraphx_status migraphx_experimental_custom_op_set_compute(
-migraphx_experimental_custom_op_set_compute(migraphx_experimental_custom_op_t obj,
+    migraphx_experimental_custom_op_t obj, migraphx_experimental_custom_op_compute input);
-                                            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

--- a/src/driver/CMakeLists.txt
+++ b/src/driver/CMakeLists.txt
@@ -45,7 +45,7 @@ if(NOT WIN32)
 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)
 rocm_install_targets(
  TARGETS driver

--- a/src/driver/argument_parser.hpp
+++ b/src/driver/argument_parser.hpp
@@ -342,7 +342,19 @@ struct argument_parser
            if(params.empty())
                throw std::runtime_error("No argument passed.");
            if(not fs::exists(params.back()))
-                throw std::runtime_error("Path does not exists: " + params.back());
+                throw std::runtime_error("Path does not exist: " + params.back());
+        });
+    }
+    MIGRAPHX_DRIVER_STATIC auto matches(const std::unordered_set<std::string>& names)
+    {
+        return validate([=](auto&, auto&, auto& params) {
+            for(const auto& p : params)
+            {
+                if(names.count(p) == 0)
+                    throw std::runtime_error("Invalid argument: " + p + ". Valid arguments are {" +
+                                             to_string_range(names) + "}");
+            }
        });
    }
@@ -570,8 +582,7 @@ struct argument_parser
                        continue;
                    if(flag[0] != '-')
                        continue;
-                    auto d =
+                    std::ptrdiff_t d = levenshtein_distance(flag, input);
-                        levenshtein_distance(flag.begin(), flag.end(), input.begin(), input.end());
                    if(d < result.distance)
                        result = result_t{&arg, flag, input, d};
                }

--- a/src/driver/main.cpp
+++ b/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>
@@ -81,6 +82,7 @@ struct loader
           {"--model"},
           ap.help("Load model"),
           ap.type("resnet50|inceptionv3|alexnet"),
+           ap.matches({"resnet50", "inceptionv3", "alexnet"}),
           ap.group("input"));
        ap(file_type, {"--onnx"}, ap.help("Load as onnx"), ap.set_value("onnx"));
        ap(file_type, {"--tf"}, ap.help("Load as tensorflow"), ap.set_value("tf"));
@@ -241,6 +243,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 +264,7 @@ struct loader
        {
            if(file_type.empty())
            {
-                if(ends_with(file, ".onnx"))
+                file_type = get_file_type(file);
-                    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";
            }
            std::cout << "Reading: " << file << std::endl;
            if(file_type == "onnx")
@@ -272,6 +281,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);
@@ -757,7 +770,7 @@ struct main_command
        {
            std::cout << "'" << color::fg_yellow << wrong_commands.front() << color::reset
                      << "' is not a valid command." << std::endl;
-            std::cout << get_command_help("Available commands:") << std::endl;
+            std::cout << get_command_help("Available commands:");
        }
        else
        {

--- a/src/dynamic_loader.cpp
+++ b/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))
 {
 }

--- a/src/include/migraphx/algorithm.hpp
+++ b/src/include/migraphx/algorithm.hpp
@@ -90,6 +90,43 @@ levenshtein_distance(Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterat
    return std::ptrdiff_t{1} + std::min({x1, x2, x3});
 }
+inline size_t levenshtein_distance(const std::string& s1, const std::string& s2)
+{
+    const size_t l1 = s1.length();
+    const size_t l2 = s2.length();
+    if(l1 < l2)
+        levenshtein_distance(s2, s1);
+    std::vector<size_t> d(l2 + 1);
+    for(size_t j = 1; j <= l2; j++)
+        d[j] = j;
+    for(size_t i = 1; i <= l1; i++)
+    {
+        size_t prev_cost = d[0];
+        d[0]             = i;
+        for(size_t j = 1; j <= l2; j++)
+        {
+            if(s1[i - 1] == s2[j - 1])
+            {
+                d[j] = prev_cost;
+            }
+            else
+            {
+                size_t cost_insert_or_delete = std::min(d[j - 1], d[j]);
+                size_t cost_substitute       = prev_cost;
+                prev_cost                    = d[j];
+                d[j]                         = std::min(cost_substitute, cost_insert_or_delete) + 1;
+            }
+        }
+    }
+    return d[l2];
+}
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

--- a/src/include/migraphx/builtin.hpp
+++ b/src/include/migraphx/builtin.hpp
@@ -90,7 +90,17 @@ struct param
 struct returns
 {
    std::string name() const { return "@return"; }
-    shape compute_shape(const std::vector<shape>&) const { return {}; }
+    shape compute_shape(const std::vector<shape>& arg) const
+    {
+        if(arg.empty())
+            return {};
+        else if(arg.size() == 1)
+            return arg[0];
+        else
+            return arg;
+    }
    argument compute(context&, const shape&, const std::vector<argument>&) const
    {
        MIGRAPHX_THROW("builtin");

--- a/src/include/migraphx/check_shapes.hpp
+++ b/src/include/migraphx/check_shapes.hpp
@@ -34,21 +34,37 @@
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
+// Check that deduced type is incrementable, dereferencable, and comparable
+template <class, class = void>
+struct is_iterator
+{
+};
+template <class T>
+struct is_iterator<T,
+                   std::void_t<decltype(++std::declval<T&>()),
+                               decltype(*std::declval<T&>()),
+                               decltype(std::declval<T&>() == std::declval<T&>())>> : std::true_type
+{
+};
+template <class Iterator>
 struct check_shapes
 {
-    const shape* begin;
+    static_assert(is_iterator<Iterator>{}, "CHECK_SHAPES: Deduced type must be an iterator");
-    const shape* end;
+    Iterator begin;
+    Iterator end;
    std::string name;
    bool dynamic_allowed;
-    check_shapes(const shape* b, const shape* e, const std::string& n, const bool d = false)
+    check_shapes(Iterator b, Iterator e, const std::string& n, const bool d = false)
        : begin(b), end(e), name(n), dynamic_allowed(d)
    {
        check_dynamic();
    }
    template <class Op>
-    check_shapes(const shape* b, const shape* e, const Op& op, const bool d = false)
+    check_shapes(Iterator b, Iterator e, const Op& op, const bool d = false)
        : begin(b), end(e), name(op.name()), dynamic_allowed(d)
    {
        check_dynamic();
@@ -56,7 +72,7 @@ struct check_shapes
    template <class Op>
    check_shapes(const std::vector<shape>& s, const Op& op, const bool d = false)
-        : begin(s.data()), end(s.data() + s.size()), name(op.name()), dynamic_allowed(d)
+        : begin(s.begin()), end(s.end()), name(op.name()), dynamic_allowed(d)
    {
        check_dynamic();
    }
@@ -81,8 +97,6 @@ struct check_shapes
    {
        if(begin == end)
            return 0;
-        assert(begin != nullptr);
-        assert(end != nullptr);
        return end - begin;
    }
@@ -131,8 +145,6 @@ struct check_shapes
     */
    const check_shapes& only_dims(std::size_t n) const
    {
-        assert(begin != nullptr);
-        assert(end != nullptr);
        if(begin != end)
        {
            if(begin->max_lens().size() != n)
@@ -148,8 +160,6 @@ struct check_shapes
     */
    const check_shapes& max_ndims(std::size_t n) const
    {
-        assert(begin != nullptr);
-        assert(end != nullptr);
        if(begin != end)
        {
            if(begin->max_lens().size() > n)
@@ -166,8 +176,6 @@ struct check_shapes
     */
    const check_shapes& min_ndims(std::size_t n) const
    {
-        assert(begin != nullptr);
-        assert(end != nullptr);
        if(begin != end)
        {
            if(begin->max_lens().size() < n)
@@ -330,8 +338,6 @@ struct check_shapes
    {
        if(begin == end)
            return true;
-        assert(begin != nullptr);
-        assert(end != nullptr);
        auto&& key = f(*begin);
        return this->all_of([&](const shape& s) { return f(s) == key; });
    }
@@ -341,8 +347,6 @@ struct check_shapes
    {
        if(begin == end)
            return true;
-        assert(begin != nullptr);
-        assert(end != nullptr);
        return std::all_of(begin, end, p);
    }
@@ -351,17 +355,13 @@ struct check_shapes
    {
        if(begin == end)
            return false;
-        assert(begin != nullptr);
-        assert(end != nullptr);
        return std::any_of(begin, end, p);
    }
-    const shape* get(long i) const
+    Iterator get(long i) const
    {
        if(i >= size())
            MIGRAPHX_THROW(prefix() + "Accessing shape out of bounds");
-        assert(begin != nullptr);
-        assert(end != nullptr);
        if(i < 0)
            return end - i;
        return begin + i;
@@ -394,6 +394,11 @@ struct check_shapes
    }
 };
+// Deduction guide for std::vector constructor
+template <class Op>
+check_shapes(const std::vector<shape>&, const Op&, bool d = false)
+    -> check_shapes<std::vector<shape>::const_iterator>;
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

--- a/src/include/migraphx/dynamic_loader.hpp
+++ b/src/include/migraphx/dynamic_loader.hpp
@@ -26,6 +26,7 @@
 #include <migraphx/config.hpp>
 #include <migraphx/filesystem.hpp>
+#include <migraphx/optional.hpp>
 #include <functional>
 #include <memory>
 #include <vector>
@@ -43,6 +44,9 @@ struct MIGRAPHX_EXPORT dynamic_loader
        return path(reinterpret_cast<void*>(address));
    }
    static fs::path path(void* address);
+    static optional<dynamic_loader> try_load(const fs::path& p);
    dynamic_loader() = default;
    dynamic_loader(const fs::path& p);

--- a/src/include/migraphx/module.hpp
+++ b/src/include/migraphx/module.hpp
@@ -222,7 +222,17 @@ struct MIGRAPHX_EXPORT module
    void annotate(std::ostream& os, std::function<void(instruction_ref)> a) const;
    std::vector<module_ref> get_sub_modules(bool shallow = false) const;
+    /* sorts the module in topological order aka reverse-post order (RPO) DFS order
+       it takes last instruction or @return as the root and walks back the graph and moves inputs
+       of the each instruction such that it appears before the instruction itself.
+    */
    module& sort();
+    /* Any instruction "X" can have module arguments and those modules inside them can use any other
+     * instruction "Y" from predecessor modules of the instruction "X". Such instruction "Y" inside
+     * module args are not listed as input instructions to "X". But those instructions "Y" must be
+     * evaluted before the instruction "X" can. Therefore such "Y" instructions are considered
+     * implicit dependency to "X".
+     */
    ins_dep_map calc_implicit_deps() const;
    MIGRAPHX_EXPORT friend std::ostream& operator<<(std::ostream& os, const module& m);

--- a/src/include/migraphx/permutation.hpp
+++ b/src/include/migraphx/permutation.hpp
@@ -66,6 +66,10 @@ MIGRAPHX_EXPORT std::vector<int64_t> invert_permutation(const std::vector<int64_
 MIGRAPHX_EXPORT std::vector<int64_t> find_permutation(const shape& s);
 MIGRAPHX_EXPORT std::vector<int64_t> find_permutation(const std::vector<shape>& shapes);
+/// Normalize the shapes so the order of dimensions will be in the order it is
+/// in memory as much as possible.
+MIGRAPHX_EXPORT std::vector<shape> normalize_permutation(const std::vector<shape>& shapes);
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

--- a/src/instruction.cpp
+++ b/src/instruction.cpp
@@ -64,10 +64,7 @@ void instruction::replace(const shape& r)
        result = r;
        for(auto&& ins : output)
        {
-            if(ins->name() == "@return")
+            assert(ins->name() == "@return" or ins->name().front() != '@');
-                continue;
-            assert(ins->name().front() != '@');
            ins->recompute_shape();
        }
    }
@@ -122,10 +119,6 @@ bool instruction::valid() const
    {
        computed = result;
    }
-    else if(op.name() == "@return")
-    {
-        computed = {};
-    }
    else
    {
        try
@@ -145,6 +138,7 @@ bool instruction::valid() const
 }
 shape instruction::get_shape() const { return result; }
 const literal& instruction::get_literal() const
 {
    assert(op.name() == "@literal");