GitLab

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.

Implements dynamic shapes in reduce_op and all its child operator classes (reduce_max etc.)

Implements the operator==(dynamic_dimension, size_t) functions

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

Changes flatten's compute_shape() to handle dynamic shapes
Calculates the flattened shape with the min, max, and opt

Currently, quantizing a program with rnn layers to fp16 results in segmentation faults due to a "convert" operation being applied to an "undefined" instruction.

The following changes are implemented to fix this issue:

Added is_undefined method to the instruction class that returns true if all inputs to the instruction are from an undefined op.
Updated rewrite_rnn pass to use the new is_undefined method rather than checking ins->name()
Updated the dead_code_elimination pass to also use this new method rather than only checking the instruction name

Extends the Argmax operator to handle dynamic input shapes.
Only shape function changes

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.

Extends unsqueeze and squeeze to work for dynamic input shapes
Does not handle the steps parameter
Adds some additional negative axes shape tests

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

Fix problem with the contiguous operator constructing non-standard shape literals.  A non-standard literal will almost never be used, since a literal is known at compile time.  Added some comments on the intended behavior:

- literal{shape, vector} constructor with a non-standard shape is intended to keep the same ordering as the given vector. The data buffer will be populated such that when the non-standard indexing is used the original order is as given.
- literal{shape, argument} constructor directly copies the data buffer from the argument
- Changed non-standard literal fill() to use tensor_view iterators as it handles non-standard shapes now
- Changed the contiguous ref_ops_test to be more helpful

Extends the pooling operators for dynamic shape inputs

AveragePooling
GlobalAveragePooling
MaxPooling
GlobalMaxPooling
LpNormPooling
GlobalLpNormPooling
y.github.com>

Extends ref transpose operator for dynamic shapes
Make dynamic tests more consistent naming

Fix to stop types failing for logical_xor during our fusions. 

Extends the ref contiguous operator to handle dynamic shapes
Updates the eliminate_contiguous pass to use the dyn_output struct

Updated Multibroadcast op to have a two input version for dynamic shapes
Current dynamic shape broadcasting logic
dynamic_dimensions must be the same or one of them is {1, 1, 0} or {1, 1, 1}
Works for dyn-dyn, dyn-static, and static-static shape combinations
Changed common.cpp for multibroadcasting for binary ops with dynamic shapes
Extended binary.hpp for dynamic shapes to test the new common.cpp stuff

Just grab the last output from the non empty branch and use the identity
operator to get the proper shape for the output branch. In the case of
an empty branch (empty tensor, of some type) this tends to mean "Do nothing"
so we're folding the output of the other flow branch here, and thus if somehow,
we do reach this at eval, should throw an error signalling either one of two things

1. Onnx model is invalid
2. The model has run into an error condition with its control flow.

Since IF is an odd operator that can adjust axes, and other operators in a data driven
fashion, this would serve as a check at compile and or/runtime.

Change things in the test cases so that we're not just replicating what
the code does but use add_instruction to dictate what we should expect
for the output of fixing empty const cases.

Had to also switch an insert to add of a literal in the empty case to achieve
this in parse_if as well.

Moved the return instructions to the end of each subgraph to also fix readability
of each test.

Default to smaller dimension with trailing 1 case instead of unsqueezing to
the larger dimension.

More analysis on other networks concludes that when putting in two operands to
and IF block, the output should take the smaller of the shapes instead of the larger

Modified tests in onnx_test.cpp to parse to the correct output as well.

Can be enabled via environment variable MIGRAPHX_ENABLE_NHWC

Newer split moves the split attribute to an input. In this case we check the
number of input args then.

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 

- Added cases to handle error cases of invalid splits for split-11 and split-13
- should solve issue with code coverage.

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

Newer split moves the split attribute to an input. In this case we check the
number of input args then.

This changes allows us to move the accumulte check to outside each conditional branch
Added more debug on this as well to show more details on this failure mode.

Adds an additional test case using a generated split-13 operator styled
test.

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

- Initial fix to handle scalars on input for empty constant values
- Using scalar, multibroadcast, contiguous
- Fixed appropriate unit tests for simple single output constants
- Added unit tests for multi if outputs.

- TODO - multibroadcast to handle scalar so we don't use scalar

Adding test to validate what a "valid" multi input should look like and
that we correctly handle trailing 1s and correctly sized outputs.

Generated and added the two tests from gen_onnx.py with matching test
in onnx_test.cpp

-if_then_else_multi_output_shapes_test.onnx
-if_then_else_multi_output_shapes_test2.onnx

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

* use find2.0 for the convolution
Co-authored-by: Vasilii Filippov <DrizztDoUrden@users.noreply.github.com>
Co-authored-by: Chris Austen <causten@users.noreply.github.com>

* Enable non-standard shape
* Use perfdb for non xdlops
* Fix transpose+broadcast strides
Co-authored-by: jungpark-mlir <jungwook.park@amd.com>

outline seems to be bugged, and going to be depreciated, thus switching to
creating a new literal with the proper shape for the empty output branch.

This test should error out as, having different output shapes for each
branch with one non empty is invalid.

Changes to gen_onnx.py as well as generated onnx file provided

Add the testcase and onnx file generated to handle the case of two output
shapes that vary in rank by one, with a trailing 1 but sub lengths are not equivalent