GitLab

Refactor to have select_module use output parameters
Disable select_module verify tests on cpu

Fixes #1595

* [MLIR] Adds a runtime switch to trigger MLIR

Add additional documentation to explain the passes.

Creates the select_module operator that selects one of the submodules passed to it to run based on the submodule parameters.  The submodule is selected by having the exact same static shapes for the arguments to select_module as the parameters in the submodule

Avoids double global loads.  Strided loops are unrolled which lets store results in array which compiler will use registers for since the index access is constant.   Updated to handle large reductions so which results with a better stable diffusion result

* deprecate HCC

* Add driver flag "--exhaustive-tune" to enable tuning, add support for the same in C/C++ and python API

Currently, we default to device 0 when loading programs. Updating this to use hipGetDevice to set the device for the loaded program.

* Fuse layernorm with different patterns
* Only match when using the last axis
Co-authored-by: kahmed10 <15948690+kahmed10@users.noreply.github.com>
Co-authored-by: kahmed10 <15948690+kahmed10@users.noreply.github.com>

Added CMakeFlag for hipRTC. MIGRAPHX_USE_HIPRTC.
Added stages in Jenkins for hipRTC.
Fixes for some of the pending issues from hipRTC.

* Add general optimize pass
* Fuse gemm multiplies by scalar
* Handle zero epsilon

This prevents multiple adds.

Extends pad operator to handle dynamic input shapes
Only handles computing the shape for adding constant padding to a dynamic shape
- adds the padding to the min, max, and opt values (unless opt is 0, where it keeps it 0)
- does not handle reflect padding with dynamic shapes

* Use cosine to compute half sin

JIT implementation of the gather operator
Added a few more unit tests to this one as well since I saw some odd behavior during bring up.

HIP had change in previous rocm releases to use --offload-arch instead of --cuda-gpu-arch.

This should be backwards compatbile. hipRTC also supports --offload-arch.

Extends dot MIGX operator to handle dynamic input shapes
Only allow dot between two dynamic shapes that have exactly matching outer dimensions
Inner dimensions must also match correspondingly
Updates dot related tests
Change check_shapes to use shape.ndim()
ONNX parsers for GEMM and MatMult will be updated in a separate PR

No major changes required, use dyn_output and pass dynamic shape when calling compute_shape()
Adds dynamic shape tests

* Add implicit_conversion

Need this for when we debug and use MIGRAPHX_TRACE_EVAL() to show tuples
Without this we break when reading our buffer due to the use of visit()
This came up as part of #1283 debugging.

Update dialect registration interface
Update 2nd build pipeline call and use full arch name

Merging #1391 caused an extra adjust allocation pass for GPU targets. This removes that merge error.

Disabling it untill int8 fix is in mainline from MIOpen and also so that QA tests could run migraphx-driver and unittests from MIGraphX.

Can be enabled via environment variable MIGRAPHX_ENABLE_NHWC

Local Threads of multiples 32 were introduced in #1348
But LocalThreads that are not multiple of 64 are causing correctness issues.

Upgraded Dockerfiles and fixed tidy issues to make Ubuntu 20.04 and ROCm 5.3.0 the default 

updated GPU pad to now use JIT version.
added range functions for JIT kernels.

Fixes an observed regression error on certain Frozen Protobuf models due to PR 1280

Reiterate the assertion on the standard shape but relax it for the multibroadcast ops deliberately inserted to explicit the broadcast.

Refactor dynamic compute
- add a compute_output_shape object that implicitly converts to a new dyn_output or shape object
- dyn_output object can handle computing the static output shape of an operator given the input arguments shapes
  change an operator's compute function to argument compute(const dyn_output& dyn_out, std::vector<argument> args) to 
  use dyn_output object

Dynamic ref unary functions
-  Included these changes to have an example of the refactored dynamic compute being used
-  Changes to unary base class to handle dynamic shapes
-  Changed elu and leaky_relu to use unary base class and pointwise JIT