Merge branch 'develop' of https://github.com/ROCmSoftwarePlatform/AMDMIGraphX into rocblas_api_opt

CMakeLists.txt

@@ -10,6 +10,12 @@ if( NOT MSVC_IDE AND NOT CMAKE_BUILD_TYPE )
     set( CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." )
 endif()
 
+# Setup valid strings for build type
+if (NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel" CACHE STRING "Configs")
+endif()
+set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES})
+
 # Default installation path
 if(WIN32)
     set(CMAKE_INSTALL_PREFIX "/opt/rocm/x86_64-w64-mingw32" CACHE PATH "")
@@ -36,21 +42,15 @@ find_package(nlohmann_json 3.8.0 REQUIRED)
 
 include(ROCMSetupVersion)
 
-rocm_setup_version(VERSION 2.0)
+rocm_setup_version(VERSION 2.1)
 set(MIGRAPHX_SO_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR})
 
 option( BUILD_SHARED_LIBS "Build as a shared library" ON )
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.4")
-        message(FATAL_ERROR "MIGraph requires at least gcc 5.4")
-    endif()
-endif()
-
 include(CheckCXXCompilerFlag)
 check_cxx_compiler_flag("--cuda-host-only -x hip" HAS_HIP)
 if(HAS_HIP)
-    message(STATUS "Enable miopen backend")
+    message(STATUS "Enable gpu backend")
     set(MIGRAPHX_ENABLE_GPU On CACHE BOOL "")
 else()
     set(MIGRAPHX_ENABLE_GPU Off CACHE BOOL "")
@@ -60,10 +60,12 @@ endif()
 set(MIGRAPHX_ENABLE_CPU Off CACHE BOOL "")
 
 set(CMAKE_CXX_STANDARD_DEFAULT "")
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    add_compile_options(-std=c++17)
+add_compile_options(-std=c++17)
+
+if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
+    set(CONFIGURE_DEPENDS)
 else()
-    add_compile_options(-std=c++14)
+    set(CONFIGURE_DEPENDS CONFIGURE_DEPENDS)
 endif()
 
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)

cmake/DoxygenDoc.cmake

-################################################################################
-# 
-# MIT License
-# 
-# Copyright (c) 2017 Advanced Micro Devices, Inc.
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# 
-################################################################################
-include(CMakeParseArguments)
-include(MainDoc)
-
-find_program(DOXYGEN_EXECUTABLE NAMES doxygen
-    PATH_SUFFIXES bin
-    DOC "Doxygen documentation generator"
-)
-mark_as_advanced(DOXYGEN_EXECUTABLE)
-
-find_path(DOT_EXECUTABLE NAMES dot
-    PATH_SUFFIXES bin
-    DOC "Graphviz"
-)
-mark_as_advanced(DOT_EXECUTABLE)
-
-set(DOXYGEN_ARGS
-ABBREVIATE_BRIEF
-ALIASES
-ALLEXTERNALS
-ALLOW_UNICODE_NAMES
-ALPHABETICAL_INDEX
-ALWAYS_DETAILED_SEC
-AUTOLINK_SUPPORT
-BINARY_TOC
-BRIEF_MEMBER_DESC
-BUILTIN_STL_SUPPORT
-CALLER_GRAPH
-CALL_GRAPH
-CASE_SENSE_NAMES
-CHM_FILE
-CHM_INDEX_ENCODING
-CITE_BIB_FILES
-CLANG_ASSISTED_PARSING
-CLANG_OPTIONS
-CLASS_DIAGRAMS
-CLASS_GRAPH
-COLLABORATION_GRAPH
-COLS_IN_ALPHA_INDEX
-COMPACT_LATEX
-COMPACT_RTF
-CPP_CLI_SUPPORT
-CREATE_SUBDIRS
-DIAFILE_DIRS
-DIA_PATH
-DIRECTORY_GRAPH
-DISABLE_INDEX
-DISTRIBUTE_GROUP_DOC
-DOCBOOK_OUTPUT
-DOCBOOK_PROGRAMLISTING
-DOCSET_BUNDLE_ID
-DOCSET_FEEDNAME
-DOCSET_PUBLISHER_ID
-DOCSET_PUBLISHER_NAME
-DOTFILE_DIRS
-DOT_CLEANUP
-DOT_FONTNAME
-DOT_FONTPATH
-DOT_FONTSIZE
-DOT_GRAPH_MAX_NODES
-DOT_IMAGE_FORMAT
-DOT_MULTI_TARGETS
-DOT_NUM_THREADS
-# DOT_PATH
-DOT_TRANSPARENT
-DOXYFILE_ENCODING
-ECLIPSE_DOC_ID
-ENABLED_SECTIONS
-ENABLE_PREPROCESSING
-ENUM_VALUES_PER_LINE
-EXAMPLE_PATH
-EXAMPLE_PATTERNS
-EXAMPLE_RECURSIVE
-EXCLUDE
-EXCLUDE_PATTERNS
-EXCLUDE_SYMBOLS
-EXCLUDE_SYMLINKS
-EXPAND_AS_DEFINED
-EXPAND_ONLY_PREDEF
-EXTENSION_MAPPING
-EXTERNAL_GROUPS
-EXTERNAL_PAGES
-EXTERNAL_SEARCH
-EXTERNAL_SEARCH_ID
-EXTRACT_ALL
-EXTRACT_ANON_NSPACES
-EXTRACT_LOCAL_CLASSES
-EXTRACT_LOCAL_METHODS
-EXTRACT_PACKAGE
-EXTRACT_PRIVATE
-EXTRACT_STATIC
-EXTRA_PACKAGES
-EXTRA_SEARCH_MAPPINGS
-EXT_LINKS_IN_WINDOW
-FILE_PATTERNS
-FILE_VERSION_FILTER
-FILTER_PATTERNS
-FILTER_SOURCE_FILES
-FILTER_SOURCE_PATTERNS
-FORCE_LOCAL_INCLUDES
-FORMULA_FONTSIZE
-FORMULA_TRANSPARENT
-FULL_PATH_NAMES
-GENERATE_AUTOGEN_DEF
-GENERATE_BUGLIST
-GENERATE_CHI
-GENERATE_DEPRECATEDLIST
-GENERATE_DOCBOOK
-GENERATE_DOCSET
-GENERATE_ECLIPSEHELP
-GENERATE_HTML
-GENERATE_HTMLHELP
-GENERATE_LATEX
-GENERATE_LEGEND
-GENERATE_MAN
-GENERATE_PERLMOD
-GENERATE_QHP
-GENERATE_RTF
-GENERATE_TAGFILE
-GENERATE_TESTLIST
-GENERATE_TODOLIST
-GENERATE_TREEVIEW
-GENERATE_XML
-GRAPHICAL_HIERARCHY
-GROUP_GRAPHS
-GROUP_NESTED_COMPOUNDS
-# HAVE_DOT
-HHC_LOCATION
-HIDE_COMPOUND_REFERENCE
-HIDE_FRIEND_COMPOUNDS
-HIDE_IN_BODY_DOCS
-HIDE_SCOPE_NAMES
-HIDE_UNDOC_CLASSES
-HIDE_UNDOC_MEMBERS
-HIDE_UNDOC_RELATIONS
-HTML_COLORSTYLE_GAMMA
-HTML_COLORSTYLE_HUE
-HTML_COLORSTYLE_SAT
-HTML_DYNAMIC_SECTIONS
-HTML_EXTRA_FILES
-HTML_EXTRA_STYLESHEET
-HTML_FILE_EXTENSION
-HTML_FOOTER
-HTML_HEADER
-HTML_INDEX_NUM_ENTRIES
-HTML_OUTPUT
-HTML_STYLESHEET
-HTML_TIMESTAMP
-IDL_PROPERTY_SUPPORT
-IGNORE_PREFIX
-IMAGE_PATH
-INCLUDED_BY_GRAPH
-INCLUDE_FILE_PATTERNS
-INCLUDE_GRAPH
-INCLUDE_PATH
-INHERIT_DOCS
-INLINE_GROUPED_CLASSES
-INLINE_INFO
-INLINE_INHERITED_MEMB
-INLINE_SIMPLE_STRUCTS
-INLINE_SOURCES
-INPUT
-INPUT_ENCODING
-INPUT_FILTER
-INTERACTIVE_SVG
-INTERNAL_DOCS
-JAVADOC_AUTOBRIEF
-LATEX_BATCHMODE
-LATEX_BIB_STYLE
-LATEX_CMD_NAME
-LATEX_EXTRA_FILES
-LATEX_EXTRA_STYLESHEET
-LATEX_FOOTER
-LATEX_HEADER
-LATEX_HIDE_INDICES
-LATEX_OUTPUT
-LATEX_SOURCE_CODE
-LATEX_TIMESTAMP
-LAYOUT_FILE
-LOOKUP_CACHE_SIZE
-MACRO_EXPANSION
-MAKEINDEX_CMD_NAME
-MAN_EXTENSION
-MAN_LINKS
-MAN_OUTPUT
-MAN_SUBDIR
-MARKDOWN_SUPPORT
-MATHJAX_CODEFILE
-MATHJAX_EXTENSIONS
-MATHJAX_FORMAT
-MATHJAX_RELPATH
-MAX_DOT_GRAPH_DEPTH
-MAX_INITIALIZER_LINES
-MSCFILE_DIRS
-MSCGEN_PATH
-MULTILINE_CPP_IS_BRIEF
-OPTIMIZE_FOR_FORTRAN
-OPTIMIZE_OUTPUT_FOR_C
-OPTIMIZE_OUTPUT_JAVA
-OPTIMIZE_OUTPUT_VHDL
-OUTPUT_DIRECTORY
-OUTPUT_LANGUAGE
-PAPER_TYPE
-PDF_HYPERLINKS
-PERLMOD_LATEX
-PERLMOD_MAKEVAR_PREFIX
-PERLMOD_PRETTY
-PERL_PATH
-PLANTUML_CFG_FILE
-PLANTUML_INCLUDE_PATH
-PLANTUML_JAR_PATH
-PREDEFINED
-PROJECT_BRIEF
-PROJECT_LOGO
-PROJECT_NAME
-PROJECT_NUMBER
-QCH_FILE
-QHG_LOCATION
-QHP_CUST_FILTER_ATTRS
-QHP_CUST_FILTER_NAME
-QHP_NAMESPACE
-QHP_SECT_FILTER_ATTRS
-QHP_VIRTUAL_FOLDER
-QT_AUTOBRIEF
-QUIET
-RECURSIVE
-REFERENCED_BY_RELATION
-REFERENCES_LINK_SOURCE
-REFERENCES_RELATION
-REPEAT_BRIEF
-RTF_EXTENSIONS_FILE
-RTF_HYPERLINKS
-RTF_OUTPUT
-RTF_SOURCE_CODE
-RTF_STYLESHEET_FILE
-SEARCHDATA_FILE
-SEARCHENGINE
-SEARCHENGINE_URL
-SEARCH_INCLUDES
-SEPARATE_MEMBER_PAGES
-SERVER_BASED_SEARCH
-SHORT_NAMES
-SHOW_FILES
-SHOW_GROUPED_MEMB_INC
-SHOW_INCLUDE_FILES
-SHOW_NAMESPACES
-SHOW_USED_FILES
-SIP_SUPPORT
-SKIP_FUNCTION_MACROS
-SORT_BRIEF_DOCS
-SORT_BY_SCOPE_NAME
-SORT_GROUP_NAMES
-SORT_MEMBERS_CTORS_1ST
-SORT_MEMBER_DOCS
-SOURCE_BROWSER
-SOURCE_TOOLTIPS
-STRICT_PROTO_MATCHING
-STRIP_CODE_COMMENTS
-STRIP_FROM_INC_PATH
-STRIP_FROM_PATH
-SUBGROUPING
-TAB_SIZE
-TAGFILES
-TCL_SUBST
-TEMPLATE_RELATIONS
-TOC_EXPAND
-TOC_INCLUDE_HEADINGS
-TREEVIEW_WIDTH
-TYPEDEF_HIDES_STRUCT
-UML_LIMIT_NUM_FIELDS
-UML_LOOK
-USE_HTAGS
-USE_MATHJAX
-USE_MDFILE_AS_MAINPAGE
-USE_PDFLATEX
-VERBATIM_HEADERS
-WARNINGS
-WARN_AS_ERROR
-WARN_FORMAT
-WARN_IF_DOC_ERROR
-WARN_IF_UNDOCUMENTED
-WARN_LOGFILE
-WARN_NO_PARAMDOC
-XML_OUTPUT
-XML_PROGRAMLISTING
-)
-
-set(DOXYGEN_CONFIG_FILE "${CMAKE_CURRENT_BINARY_DIR}/doxygen/doxygen.conf" CACHE PATH "Path to generated doxygen configuration file")
-
-function(add_doxygen_doc)
-    set(options)
-    set(oneValueArgs)
-    set(multiValueArgs DEPENDS ${DOXYGEN_ARGS})
-
-    cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    file(WRITE ${DOXYGEN_CONFIG_FILE} "# Auto-generated doxygen configuration file\n")
-
-    if(NOT PARSE_STRIP_FROM_PATH)
-        set(PARSE_STRIP_FROM_PATH ${CMAKE_SOURCE_DIR})
-    endif()
-
-    foreach(ARG ${DOXYGEN_ARGS})
-        if(PARSE_${ARG})
-            string(REPLACE ";" " " ARG_VALUE "${PARSE_${ARG}}")
-            file(APPEND ${DOXYGEN_CONFIG_FILE} "\n${ARG} = ${ARG_VALUE}\n")
-        endif()
-    endforeach()
-
-    if(PARSE_OUTPUT_DIRECTORY)
-        if(NOT EXISTS ${PARSE_OUTPUT_DIRECTORY})
-            file(MAKE_DIRECTORY ${PARSE_OUTPUT_DIRECTORY})
-        endif()
-    endif()
-
-    if(DOT_EXECUTABLE)
-        file(APPEND ${DOXYGEN_CONFIG_FILE} "\nDOT_PATH = \"${DOT_EXECUTABLE}\"\n")
-        file(APPEND ${DOXYGEN_CONFIG_FILE} "\nHAVE_DOT = YES\n")
-    else()
-        file(APPEND ${DOXYGEN_CONFIG_FILE} "\nHAVE_DOT = NO\n")
-    endif()
-
-    add_custom_target(doxygen
-        ${DOXYGEN_EXECUTABLE} ${DOXYGEN_CONFIG_FILE}
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        COMMENT "Building documentation with doxygen"
-    )
-    if(PARSE_OUTPUT_DIRECTORY)
-        clean_doc_output(${PARSE_OUTPUT_DIRECTORY})
-    endif()
-    mark_as_doc(doxygen)
-    if(PARSE_DEPENDS)
-        add_dependencies(doxygen ${PARSE_DEPENDS})
-    endif()
-endfunction()

cmake/MainDoc.cmake

-################################################################################
-# 
-# MIT License
-# 
-# Copyright (c) 2017 Advanced Micro Devices, Inc.
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# 
-################################################################################
-
-if(NOT TARGET doc)
-    add_custom_target(doc)
-endif()
-
-function(mark_as_doc)
-    add_dependencies(doc ${ARGN})
-endfunction()
-
-function(clean_doc_output DIR)
-    set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${DIR})
-endfunction()

cmake/SphinxDoc.cmake

-################################################################################
-# 
-# MIT License
-# 
-# Copyright (c) 2017 Advanced Micro Devices, Inc.
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# 
-################################################################################
-include(CMakeParseArguments)
-include(MainDoc)
-include(DoxygenDoc)
-
-find_program(SPHINX_EXECUTABLE NAMES sphinx-build
-    HINTS
-    $ENV{SPHINX_DIR}
-    PATH_SUFFIXES bin
-    DOC "Sphinx documentation generator"
-)
-
-mark_as_advanced(SPHINX_EXECUTABLE)
-
-set(BINARY_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/sphinx/_build")
- 
-# Sphinx cache with pickled ReST documents
-set(SPHINX_CACHE_DIR "${CMAKE_CURRENT_BINARY_DIR}/sphinx/_doctrees")
- 
-# HTML output directory
-set(SPHINX_DEFAULT_HTML_DIR "${CMAKE_CURRENT_BINARY_DIR}/sphinx/html")
-function(add_sphinx_doc SRC_DIR)
-    set(options)
-    set(oneValueArgs BUILDER OUTPUT_DIR)
-    set(multiValueArgs DEPENDS VARS TEMPLATE_VARS)
-
-    cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    string(TOUPPER ${PARSE_BUILDER} BUILDER)
-
-    set(ADDITIONAL_ARGS)
-    foreach(VAR ${PARSE_VARS})
-        list(APPEND ADDITIONAL_ARGS -D ${VAR})
-    endforeach()
-    foreach(VAR ${PARSE_TEMPLATE_VARS})
-        list(APPEND ADDITIONAL_ARGS -A ${VAR})
-    endforeach()
-
-    if(PARSE_OUTPUT_DIR)
-        get_filename_component(OUTPUT_DIR ${PARSE_OUTPUT_DIR} ABSOLUTE)
-        set(SPHINX_${BUILDER}_DIR ${OUTPUT_DIR} CACHE PATH "Path to ${PARSE_BUILDER} output")
-    else()
-        set(SPHINX_${BUILDER}_DIR "${CMAKE_CURRENT_BINARY_DIR}/sphinx/${PARSE_BUILDER}" CACHE PATH "Path to ${PARSE_BUILDER} output")
-    endif()
-
-    add_custom_target(sphinx-${BUILDER}
-        ${SPHINX_EXECUTABLE}
-        -b ${PARSE_BUILDER}
-        -d "${SPHINX_CACHE_DIR}"
-        ${ADDITIONAL_ARGS}
-        "${SRC_DIR}"
-        "${SPHINX_${BUILDER}_DIR}"
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        COMMENT "Building ${PARSE_BUILDER} documentation with Sphinx"
-    )
-    clean_doc_output(${SPHINX_${BUILDER}_DIR})
-    clean_doc_output(${SPHINX_CACHE_DIR})
-    clean_doc_output(${BINARY_BUILD_DIR})
-    mark_as_doc(sphinx-${BUILDER})
-    if(PARSE_DEPENDS)
-        add_dependencies(sphinx-${BUILDER} ${PARSE_DEPENDS})
-    endif()
-
-endfunction()
-
-

dev-requirements.txt

@@ -3,5 +3,5 @@ facebook/zstd@v1.4.5 -X subdir -DCMAKE_DIR=build/cmake
 ccache@v4.1
 pcre,pfultz2/pcre@8.45 -H sha256:d6f7182602a775a7d500a0cedca6449af0400c6493951513046d17615ed0bf11
 danmar/cppcheck@2.6 -DHAVE_RULES=1
-RadeonOpenCompute/rocm-cmake@ececd2eccae4d01e7ec154efe90ac43ebf4df317 --build
+RadeonOpenCompute/rocm-cmake@1ebf7e7bc61bb5e949c171562b421264065230a7 --build
 -f requirements.txt

doc/CMakeLists.txt

 
-include(DoxygenDoc)
+project(migraphx-doc)
+find_package(ROCM REQUIRED)
+
+include(ROCMDoxygenDoc)
 
 set(DOXYGEN_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/doxygen/)
-add_doxygen_doc(
+rocm_add_doxygen_doc(
     OUTPUT_DIRECTORY ${DOXYGEN_OUTPUT}
     INPUT 
         ${PROJECT_SOURCE_DIR}/src
@@ -39,8 +42,8 @@ add_doxygen_doc(
     PREDEFINED DOXYGEN
 )
 
-include(SphinxDoc)
-add_sphinx_doc(src 
+include(ROCMSphinxDoc)
+rocm_add_sphinx_doc(src 
     BUILDER html 
     OUTPUT_DIR html 
     VARS 
@@ -51,7 +54,7 @@ add_sphinx_doc(src
 
 find_package(LATEX)
 if(LATEX_FOUND)
-    add_sphinx_doc(src 
+    rocm_add_sphinx_doc(src 
         BUILDER latex
         OUTPUT_DIR pdf
         VARS 

examples/nlp/python_bert_squad/requirements_bertsquad.txt

-tensorflow==2.5.2
+tensorflow==2.5.3
 onnxruntime
 tokenizers
\ No newline at end of file

src/CMakeLists.txt

@@ -211,7 +211,6 @@ target_link_libraries(migraphx PRIVATE msgpackc-cxx)
 target_link_libraries(migraphx INTERFACE $<BUILD_INTERFACE:msgpackc-cxx>)
 
 add_library(migraphx_all_targets INTERFACE)
-target_link_libraries(migraphx_all_targets INTERFACE migraphx_ref)
 
 set(PACKAGE_DEPENDS)
 
@@ -222,6 +221,7 @@ add_subdirectory(tf)
 
 add_subdirectory(py)
 add_subdirectory(targets/ref)
+target_link_libraries(migraphx_all_targets INTERFACE migraphx_ref)
 if(MIGRAPHX_ENABLE_CPU)
 add_subdirectory(targets/cpu)
 target_link_libraries(migraphx_all_targets INTERFACE migraphx_cpu)
@@ -239,7 +239,7 @@ if(HAVE_HALF_EXPR)
 endif()
 
 rocm_export_targets(
-  TARGETS migraphx::migraphx migraphx_all_targets
+  TARGETS migraphx::migraphx_c
   NAMESPACE migraphx::
   DEPENDS
     Threads

src/api/api.cpp

@@ -385,6 +385,13 @@ extern "C" migraphx_status migraphx_shape_destroy(migraphx_shape_t shape)
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_shape_assign_to(migraphx_shape_t output,
+                                                    const_migraphx_shape_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_shape_create(migraphx_shape_t* shape,
                                                  migraphx_shape_datatype_t type,
                                                  size_t* lengths,
@@ -502,6 +509,13 @@ extern "C" migraphx_status migraphx_argument_destroy(migraphx_argument_t argumen
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_argument_assign_to(migraphx_argument_t output,
+                                                       const_migraphx_argument_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status
 migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer)
 {
@@ -565,6 +579,13 @@ extern "C" migraphx_status migraphx_target_destroy(migraphx_target_t target)
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_target_assign_to(migraphx_target_t output,
+                                                     const_migraphx_target_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_target_create(migraphx_target_t* target, const char* name)
 {
     auto api_error_result = migraphx::try_([&] {
@@ -581,6 +602,14 @@ extern "C" migraphx_status migraphx_program_parameter_shapes_destroy(
     return api_error_result;
 }
 
+extern "C" migraphx_status
+migraphx_program_parameter_shapes_assign_to(migraphx_program_parameter_shapes_t output,
+                                            const_migraphx_program_parameter_shapes_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status
 migraphx_program_parameter_shapes_size(size_t* out,
                                        migraphx_program_parameter_shapes_t program_parameter_shapes)
@@ -631,6 +660,14 @@ migraphx_program_parameters_destroy(migraphx_program_parameters_t program_parame
     return api_error_result;
 }
 
+extern "C" migraphx_status
+migraphx_program_parameters_assign_to(migraphx_program_parameters_t output,
+                                      const_migraphx_program_parameters_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status
 migraphx_program_parameters_create(migraphx_program_parameters_t* program_parameters)
 {
@@ -663,6 +700,13 @@ extern "C" migraphx_status migraphx_arguments_destroy(migraphx_arguments_t argum
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_arguments_assign_to(migraphx_arguments_t output,
+                                                        const_migraphx_arguments_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_arguments_size(size_t* out, migraphx_arguments_t arguments)
 {
     auto api_error_result = migraphx::try_([&] {
@@ -690,6 +734,13 @@ extern "C" migraphx_status migraphx_shapes_destroy(migraphx_shapes_t shapes)
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_shapes_assign_to(migraphx_shapes_t output,
+                                                     const_migraphx_shapes_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_shapes_size(size_t* out, migraphx_shapes_t shapes)
 {
     auto api_error_result = migraphx::try_([&] {
@@ -727,6 +778,13 @@ extern "C" migraphx_status migraphx_program_destroy(migraphx_program_t program)
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_program_assign_to(migraphx_program_t output,
+                                                      const_migraphx_program_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_program_get_main_module(migraphx_module_t* out,
                                                             migraphx_program_t program)
 {
@@ -831,6 +889,13 @@ extern "C" migraphx_status migraphx_operation_destroy(migraphx_operation_t opera
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_operation_assign_to(migraphx_operation_t output,
+                                                        const_migraphx_operation_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_operation_create(migraphx_operation_t* operation,
                                                      const char* name,
                                                      const char* attributes,
@@ -891,6 +956,13 @@ extern "C" migraphx_status migraphx_onnx_options_destroy(migraphx_onnx_options_t
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_onnx_options_assign_to(migraphx_onnx_options_t output,
+                                                           const_migraphx_onnx_options_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_onnx_options_create(migraphx_onnx_options_t* onnx_options)
 {
     auto api_error_result = migraphx::try_([&] {
@@ -942,6 +1014,13 @@ extern "C" migraphx_status migraphx_file_options_destroy(migraphx_file_options_t
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_file_options_assign_to(migraphx_file_options_t output,
+                                                           const_migraphx_file_options_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_file_options_create(migraphx_file_options_t* file_options)
 {
     auto api_error_result = migraphx::try_([&] {
@@ -968,6 +1047,14 @@ migraphx_compile_options_destroy(migraphx_compile_options_t compile_options)
     return api_error_result;
 }
 
+extern "C" migraphx_status
+migraphx_compile_options_assign_to(migraphx_compile_options_t output,
+                                   const_migraphx_compile_options_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status
 migraphx_compile_options_create(migraphx_compile_options_t* compile_options)
 {
@@ -1033,6 +1120,13 @@ extern "C" migraphx_status migraphx_tf_options_destroy(migraphx_tf_options_t tf_
     return api_error_result;
 }
 
+extern "C" migraphx_status migraphx_tf_options_assign_to(migraphx_tf_options_t output,
+                                                         const_migraphx_tf_options_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status migraphx_tf_options_create(migraphx_tf_options_t* tf_options)
 {
     auto api_error_result = migraphx::try_([&] {
@@ -1110,6 +1204,14 @@ migraphx_quantize_op_names_destroy(migraphx_quantize_op_names_t quantize_op_name
     return api_error_result;
 }
 
+extern "C" migraphx_status
+migraphx_quantize_op_names_assign_to(migraphx_quantize_op_names_t output,
+                                     const_migraphx_quantize_op_names_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status
 migraphx_quantize_op_names_create(migraphx_quantize_op_names_t* quantize_op_names)
 {
@@ -1162,6 +1264,14 @@ migraphx_quantize_int8_options_destroy(migraphx_quantize_int8_options_t quantize
     return api_error_result;
 }
 
+extern "C" migraphx_status
+migraphx_quantize_int8_options_assign_to(migraphx_quantize_int8_options_t output,
+                                         const_migraphx_quantize_int8_options_t input)
+{
+    auto api_error_result = migraphx::try_([&] { *output = *input; });
+    return api_error_result;
+}
+
 extern "C" migraphx_status
 migraphx_quantize_int8_options_create(migraphx_quantize_int8_options_t* quantize_int8_options)
 {

src/api/include/migraphx/migraphx.h

@@ -91,6 +91,8 @@ typedef const struct migraphx_quantize_int8_options* const_migraphx_quantize_int
 
 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_status migraphx_shape_create(migraphx_shape_t* shape,
                                       migraphx_shape_datatype_t type,
                                       size_t* lengths,
@@ -121,6 +123,9 @@ migraphx_shape_equal(bool* out, const_migraphx_shape_t shape, const_migraphx_sha
 
 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_status
 migraphx_argument_create(migraphx_argument_t* argument, const_migraphx_shape_t shape, void* buffer);
 
@@ -137,11 +142,17 @@ migraphx_argument_generate(migraphx_argument_t* out, const_migraphx_shape_t s, s
 
 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_status migraphx_target_create(migraphx_target_t* target, const char* name);
 
 migraphx_status migraphx_program_parameter_shapes_destroy(
     migraphx_program_parameter_shapes_t program_parameter_shapes);
 
+migraphx_status
+migraphx_program_parameter_shapes_assign_to(migraphx_program_parameter_shapes_t output,
+                                            const_migraphx_program_parameter_shapes_t input);
+
 migraphx_status migraphx_program_parameter_shapes_size(
     size_t* out, migraphx_program_parameter_shapes_t program_parameter_shapes);
 
@@ -156,6 +167,9 @@ migraphx_status migraphx_program_parameter_shapes_names(
 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_status
 migraphx_program_parameters_create(migraphx_program_parameters_t* program_parameters);
 
@@ -165,6 +179,9 @@ migraphx_status migraphx_program_parameters_add(migraphx_program_parameters_t pr
 
 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_status migraphx_arguments_size(size_t* out, migraphx_arguments_t arguments);
 
 migraphx_status
@@ -172,6 +189,8 @@ migraphx_arguments_get(const_migraphx_argument_t* out, migraphx_arguments_t argu
 
 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_status migraphx_shapes_size(size_t* out, migraphx_shapes_t shapes);
 
 migraphx_status
@@ -181,6 +200,9 @@ migraphx_status migraphx_module_print(const_migraphx_module_t module);
 
 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_status migraphx_program_get_main_module(migraphx_module_t* out,
                                                  migraphx_program_t program);
 
@@ -207,6 +229,9 @@ migraphx_program_equal(bool* out, const_migraphx_program_t program, const_migrap
 
 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_status migraphx_operation_create(migraphx_operation_t* operation,
                                           const char* name,
                                           const char* attributes,
@@ -222,6 +247,9 @@ migraphx_save(migraphx_program_t p, const char* name, migraphx_file_options_t op
 
 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_status migraphx_onnx_options_create(migraphx_onnx_options_t* onnx_options);
 
 migraphx_status migraphx_onnx_options_set_input_parameter_shape(
@@ -236,6 +264,9 @@ migraphx_onnx_options_set_default_loop_iterations(migraphx_onnx_options_t onnx_o
 
 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_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,
@@ -243,6 +274,9 @@ migraphx_status migraphx_file_options_set_file_format(migraphx_file_options_t fi
 
 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_status migraphx_compile_options_create(migraphx_compile_options_t* compile_options);
 
 migraphx_status
@@ -261,6 +295,9 @@ migraphx_status migraphx_parse_onnx_buffer(migraphx_program_t* out,
 
 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_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);
@@ -282,6 +319,9 @@ migraphx_parse_tf(migraphx_program_t* out, const char* name, migraphx_tf_options
 
 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_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,
@@ -295,6 +335,10 @@ migraphx_status migraphx_quantize_fp16(migraphx_program_t prog);
 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_status
 migraphx_quantize_int8_options_create(migraphx_quantize_int8_options_t* quantize_int8_options);
 

src/api/include/migraphx/migraphx.hpp

@@ -152,6 +152,35 @@ struct array_base
     }
 };
 
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnon-template-friend"
+#endif
+
+template <class T>
+struct holder
+{
+    // Friend injection
+    friend auto migraphx_adl_handle_lookup(holder<T>);
+    // Function left unimplemented since its only used in non-evaluated
+    // context
+    T get() const;
+};
+
+template <class C, class T>
+struct handle_lookup
+{
+    friend auto migraphx_adl_handle_lookup(holder<T>) { return holder<C>{}; }
+};
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+template <class T>
+using as_handle = decltype(
+    migraphx_adl_handle_lookup(holder<std::remove_cv_t<std::remove_pointer_t<T>>>{}).get());
+
 struct own
 {
 };
@@ -159,8 +188,8 @@ struct borrow
 {
 };
 
-template <class T, class D, D Deleter>
-struct handle_base
+template <class Derived, class T, class D, D Deleter, class A, A Assigner>
+struct handle_base : handle_lookup<Derived, std::remove_cv_t<T>>
 {
     handle_base() : m_handle(nullptr) {}
     template <class F, class... Ts>
@@ -190,6 +219,12 @@ struct handle_base
         m_handle = std::shared_ptr<U>{ptr, [](U*) {}};
     }
 
+    template <class U>
+    void assign_to_handle(U* x)
+    {
+        Assigner(x, this->get_handle_ptr());
+    }
+
     protected:
     std::shared_ptr<T> m_handle;
 };
@@ -198,9 +233,12 @@ struct handle_base
 #define MIGRAPHX_DETAIL_HANDLE_BASE(name, const_) handle_base<>
 #else
 #define MIGRAPHX_DETAIL_HANDLE_BASE(name, const_)       \
-    handle_base<const_ migraphx_##name,               \
+    handle_base<name,                                   \
+                const_ migraphx_##name,                 \
                 decltype(&migraphx_##name##_destroy),   \
-                migraphx_##name##_destroy>
+                migraphx_##name##_destroy,              \
+                decltype(&migraphx_##name##_assign_to), \
+                migraphx_##name##_assign_to>
 #endif
 // NOLINTNEXTLINE
 #define MIGRAPHX_HANDLE_BASE(name) MIGRAPHX_DETAIL_HANDLE_BASE(name, )

src/auto_contiguous.cpp

@@ -10,8 +10,35 @@ inline namespace MIGRAPHX_INLINE_NS {
 
 void auto_contiguous::apply(module& p) const
 {
+    std::string key = "require_std_shape";
+    for(auto ins : reverse_iterator_for(p))
+    {
+        auto&& attr = ins->get_operator().attributes();
+        if((attr.get(key, false)))
+        {
+            auto args     = ins->inputs();
+            auto new_args = args;
+            std::transform(args.begin(), args.end(), new_args.begin(), [&](auto in) {
+                if(in->name() == "contiguous")
+                {
+                    return in;
+                }
+                return p.insert_instruction(ins, make_op("contiguous"), in);
+            });
+
+            if(new_args != args)
+            {
+                p.replace_instruction(ins, ins->get_operator(), new_args);
+            }
+        }
+    }
+
+    auto last = std::prev(p.end());
     for(auto ins : iterator_for(p))
     {
+        // for last instruction that is NOT a return
+        if(ins->outputs().empty() and ins != last)
+            continue;
         shape s = ins->get_shape();
         if(not s.standard() and s.elements() != 0)
         {

src/eliminate_contiguous.cpp

@@ -79,14 +79,15 @@ void eliminate_contiguous::apply(module& p) const
 
         // Make a copy so we can modify it while we iterate
         auto args     = ins->inputs();
+        auto new_args = args;
+        auto mod_args = ins->module_inputs();
         for(auto arg : ins->inputs())
         {
             if(arg->name() == op_name)
             {
-                auto new_args = args;
                 auto prev = arg->inputs().front();
                 replace(new_args, arg, prev);
-                if(try_compute_shape(ins, new_args, ins->module_inputs()))
+                if(try_compute_shape(ins, new_args, mod_args))
                 {
                     instruction::replace_argument(ins, arg, prev);
                 }

src/include/migraphx/any_ptr.hpp

+#ifndef MIGRAPHX_GUARD_MIGRAPHX_ANY_PTR_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_ANY_PTR_HPP
+
+#include <migraphx/config.hpp>
+#include <migraphx/optional.hpp>
+#include <migraphx/errors.hpp>
+#include <migraphx/type_name.hpp>
+#include <cassert>
+#include <string_view>
+#include <typeindex>
+#include <type_traits>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+struct any_ptr
+{
+    any_ptr() = default;
+    template <class T>
+    any_ptr(T* p) : ptr(p), ti(typeid(T*)), name(get_name<T*>())
+    {
+    }
+
+    any_ptr(void* p, std::string_view pname) : ptr(p), name(pname) {}
+
+    void* get(std::string_view n) const
+    {
+        if(name != n)
+            MIGRAPHX_THROW("any_ptr: type mismatch: " + std::string{name} +
+                           " != " + std::string{n});
+        return ptr;
+    }
+
+    template <class T>
+    T get() const
+    {
+        static_assert(std::is_pointer<T>{}, "Must be a pointer");
+        assert(ptr != nullptr);
+        if(ti and std::type_index{typeid(T)} != *ti)
+            MIGRAPHX_THROW("any_ptr: type mismatch: " + std::string{name} + " != " + get_name<T>());
+        else if(name != get_name<T>())
+            MIGRAPHX_THROW("any_ptr: type mismatch: " + std::string{name} + " != " + get_name<T>());
+        return reinterpret_cast<T>(ptr);
+    }
+    void* unsafe_get() const { return ptr; }
+
+    private:
+    void* ptr                    = nullptr;
+    optional<std::type_index> ti = nullopt;
+    std::string_view name        = "";
+
+    template <class T>
+    static const std::string& get_name()
+    {
+        return get_type_name<std::remove_cv_t<std::remove_pointer_t<T>>>();
+    }
+};
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+#endif // MIGRAPHX_GUARD_MIGRAPHX_ANY_PTR_HPP

src/include/migraphx/context.hpp

@@ -9,6 +9,7 @@
 #include <utility>
 #include <migraphx/config.hpp>
 #include <migraphx/value.hpp>
+#include <migraphx/any_ptr.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -37,6 +38,12 @@ void from_value_context(T&, const value&)
 {
 }
 
+template <class T>
+any_ptr get_queue_context(T&)
+{
+    return {};
+}
+
 /*
  * Type-erased interface for:
  *
@@ -44,6 +51,7 @@ void from_value_context(T&, const value&)
  * {
  *      value to_value() const;
  *      void from_value(const value& v) ;
+ *      any_ptr get_queue() ;
  *      void finish() const;
  * };
  *
@@ -124,6 +132,12 @@ struct context
         (*this).private_detail_te_get_handle().from_value(v);
     }
 
+    any_ptr get_queue()
+    {
+        assert((*this).private_detail_te_handle_mem_var);
+        return (*this).private_detail_te_get_handle().get_queue();
+    }
+
     void finish() const
     {
         assert((*this).private_detail_te_handle_mem_var);
@@ -145,6 +159,7 @@ struct context
 
         virtual value to_value() const          = 0;
         virtual void from_value(const value& v) = 0;
+        virtual any_ptr get_queue()             = 0;
         virtual void finish() const             = 0;
     };
 
@@ -176,6 +191,19 @@ struct context
         from_value_context(private_detail_te_self, v);
     }
 
+    template <class T>
+    static auto private_detail_te_default_get_queue(char, T&& private_detail_te_self)
+        -> decltype(private_detail_te_self.get_queue())
+    {
+        return private_detail_te_self.get_queue();
+    }
+
+    template <class T>
+    static any_ptr private_detail_te_default_get_queue(float, T&& private_detail_te_self)
+    {
+        return get_queue_context(private_detail_te_self);
+    }
+
     template <typename PrivateDetailTypeErasedT>
     struct private_detail_te_handle_type : private_detail_te_handle_base_type
     {
@@ -216,6 +244,12 @@ struct context
             private_detail_te_default_from_value(char(0), private_detail_te_value, v);
         }
 
+        any_ptr get_queue() override
+        {
+
+            return private_detail_te_default_get_queue(char(0), private_detail_te_value);
+        }
+
         void finish() const override { private_detail_te_value.finish(); }
 
         PrivateDetailTypeErasedT private_detail_te_value;

src/include/migraphx/op/reshape.hpp

@@ -9,6 +9,7 @@
 #include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
 #include <migraphx/lifetime.hpp>
+#include <migraphx/value.hpp>
 #include <cmath>
 #include <utility>
 
@@ -26,6 +27,8 @@ struct reshape
         return pack(f(self.dims, "dims"));
     }
 
+    value attributes() const { return {{"require_std_shape", true}}; }
+
     std::string name() const { return "reshape"; }
     shape compute_shape(std::vector<shape> inputs) const
     {

src/include/migraphx/op/unsqueeze.hpp

@@ -37,11 +37,11 @@ struct unsqueeze
     std::string name() const { return "unsqueeze"; }
     shape normalize_compute_shape(std::vector<shape> inputs) const
     {
-        check_shapes{inputs, *this}.has(1).standard_or_scalar();
+        check_shapes{inputs, *this}.has(1);
         auto input_shape = inputs[0];
         auto type        = input_shape.type();
         auto old_lens    = input_shape.lens();
-
+        auto old_strides = input_shape.strides();
         if(input_shape.scalar())
         {
             if(old_lens.size() == 1 and old_lens.front() == 1)
@@ -53,19 +53,29 @@ struct unsqueeze
         std::size_t new_size = old_lens.size() + axes.size();
 
         std::vector<std::size_t> new_lens(new_size);
+        std::vector<std::size_t> new_strides(new_size);
         std::size_t p = 0;
-        for(std::size_t i = 0; i < new_size; i++)
+        for(auto i : range(new_size))
         {
             if(std::find(axes.begin(), axes.end(), i) != axes.end())
             {
                 new_lens[i] = 1;
+                if(p == 0) // unsqueeze on the first axes
+                {
+                    new_strides[i] = old_lens[0] * old_strides[0];
+                }
+                else // unsqueeze on middle or last axes
+                {
+                    new_strides[i] = (p < old_strides.size()) ? old_strides[p - 1] : 1;
+                }
             }
             else
             {
-                new_lens[i] = old_lens[p++];
+                new_lens[i]    = old_lens[p];
+                new_strides[i] = old_strides[p++];
             }
         }
-        return shape{type, new_lens};
+        return shape{type, new_lens, new_strides};
     }
     argument compute(shape output_shape, std::vector<argument> args) const
     {

src/onnx/CMakeLists.txt

@@ -7,7 +7,7 @@ target_compile_options(onnx-proto PRIVATE -w)
 target_link_libraries(onnx-proto PRIVATE ${PROTOBUF_LIBRARY})
 set_target_properties(onnx-proto PROPERTIES POSITION_INDEPENDENT_CODE On)
 
-file(GLOB ONNX_SRCS *.cpp)
+file(GLOB ONNX_SRCS ${CONFIGURE_DEPENDS} *.cpp)
 add_library(migraphx_onnx ${ONNX_SRCS})
 target_include_directories(migraphx_onnx PRIVATE include)
 set_target_properties(migraphx_onnx PROPERTIES EXPORT_NAME onnx)

src/onnx/onnx_parser.cpp

@@ -70,12 +70,14 @@ static literal from_repeated(shape::type_t t, const T& r)
 
 instruction_ref onnx_parser::node_info::make_contiguous(instruction_ref ins) const
 {
-    if(ins->get_shape().standard())
+    auto attr       = ins->get_operator().to_value();
+    std::string key = "require_std_shape";
+    if((attr.get(key, false)) or (not ins->get_shape().standard()))
     {
-        return ins;
+        return add_instruction(make_op("contiguous"), ins);
     }
 
-    return add_instruction(make_op("contiguous"), ins);
+    return ins;
 }
 
 instruction_ref onnx_parser::node_info::add_bias(const std::vector<instruction_ref>& args,

src/targets/gpu/CMakeLists.txt

@@ -11,7 +11,7 @@ if(NOT TARGET MIOpen)
 endif()
 
 include(Embed)
-file(GLOB KERNEL_FILES
+file(GLOB KERNEL_FILES ${CONFIGURE_DEPENDS}
     ${CMAKE_CURRENT_SOURCE_DIR}/kernels/include/migraphx/kernels/*.hpp)
 message(STATUS "KERNEL_FILES: ${KERNEL_FILES}")
 add_embed_library(migraphx_kernels ${KERNEL_FILES})