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

src/include/migraphx/op/sinh.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_SINH_HPP
+#define MIGRAPHX_GUARD_OPERATORS_SINH_HPP
+
+#include <array>
+#include <migraphx/op/unary.hpp>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct sinh : unary
+{
+    std::string name() const { return "sinh"; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/slice.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_SLICE_HPP
+#define MIGRAPHX_GUARD_OPERATORS_SLICE_HPP
+
+#include <array>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct slice
+{
+    std::vector<int64_t> axes;
+    std::vector<int64_t> starts;
+    std::vector<int64_t> ends;
+
+    template <class Self, class F>
+    static auto reflect(Self& self, F f)
+    {
+        return pack(f(self.axes, "axes"), f(self.starts, "starts"), f(self.ends, "ends"));
+    }
+
+    std::string name() const { return "slice"; }
+
+    auto fix_index(const std::vector<std::size_t>& lens, std::size_t axis, int64_t index) const
+    {
+        int64_t r = std::min(index, static_cast<int64_t>(lens[axis]));
+        if(r < 0)
+            r += lens[axis];
+        return std::size_t(r);
+    }
+
+    auto compute_offset(const shape& s) const
+    {
+        const std::vector<std::size_t>& lens    = s.lens();
+        const std::vector<std::size_t>& strides = s.strides();
+        auto offset                             = 0;
+        if(!axes.empty())
+        {
+            for(std::size_t i = 0; i < axes.size(); i++)
+            {
+                auto axis = axes[i];
+                offset += fix_index(lens, axis, starts[i]) * strides[axis];
+            }
+        }
+        else
+        {
+            for(std::size_t axis = 0; axis < lens.size(); axis++)
+            {
+                offset += fix_index(lens, axis, starts[axis]) * strides[axis];
+            }
+        }
+        return offset;
+    }
+
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        auto input_shape        = inputs[0];
+        auto t                  = input_shape.type();
+        const auto& old_lens    = input_shape.lens();
+        const auto& old_strides = input_shape.strides();
+        if(starts.size() != axes.size() || axes.size() != ends.size())
+        {
+            MIGRAPHX_THROW("inconsistent sizes");
+        }
+        std::vector<std::size_t> new_lens = old_lens;
+        for(std::size_t i = 0; i < axes.size(); i++)
+        {
+            auto axis = axes[i];
+            new_lens[axis] =
+                fix_index(old_lens, axis, ends[i]) - fix_index(old_lens, axis, starts[i]);
+        }
+        return shape{t, new_lens, old_strides};
+    }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        auto input  = args[0];
+        auto offset = compute_offset(input.get_shape()) * output_shape.type_size();
+        return {std::move(output_shape), [=] { return input.data() + offset; }};
+    }
+    int output_alias(const std::vector<shape>&) const { return 0; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/softmax.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_SOFTMAX_HPP
+#define MIGRAPHX_GUARD_OPERATORS_SOFTMAX_HPP
+
+#include <array>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct softmax
+{
+    std::string name() const { return "softmax"; }
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        check_shapes{inputs}.has(1).only_dims(4);
+        return inputs.at(0);
+    }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/squeeze.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_SQUEEZE_HPP
+#define MIGRAPHX_GUARD_OPERATORS_SQUEEZE_HPP
+
+#include <array>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct squeeze
+{
+    std::vector<int64_t> axes;
+
+    template <class Self, class F>
+    static auto reflect(Self& self, F f)
+    {
+        return pack(f(self.axes, "axes"));
+    }
+
+    std::string name() const { return "squeeze"; }
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        auto input_shape = inputs[0];
+        auto type        = input_shape.type();
+        auto old_lens    = input_shape.lens();
+        if(std::any_of(
+               axes.begin(), axes.end(), [&](auto axis) { return input_shape.lens()[axis] != 1; }))
+        {
+            MIGRAPHX_THROW("squeeze axis dimension should be equal to 1");
+        }
+        std::vector<std::size_t> new_lens;
+        if(axes.empty())
+        {
+            std::copy_if(old_lens.begin(),
+                         old_lens.end(),
+                         std::back_inserter(new_lens),
+                         [](auto len) { return len != 1; });
+        }
+        else
+        {
+            for(std::size_t i = 0; i < old_lens.size(); i++)
+            {
+                if(std::find(axes.begin(), axes.end(), i) == axes.end())
+                {
+                    new_lens.push_back(old_lens[i]);
+                }
+            }
+        }
+
+        if(new_lens.empty())
+        {
+            return shape{type};
+        }
+        else
+        {
+            return shape{type, new_lens};
+        }
+    }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        return {std::move(output_shape), std::move(args.front().data)};
+    }
+    int output_alias(const std::vector<shape>&) const { return 0; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/sub.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_SUB_HPP
+#define MIGRAPHX_GUARD_OPERATORS_SUB_HPP
+
+#include <array>
+#include <migraphx/op/binary.hpp>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct sub : binary
+{
+    std::string name() const { return "sub"; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/tan.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_TAN_HPP
+#define MIGRAPHX_GUARD_OPERATORS_TAN_HPP
+
+#include <array>
+#include <migraphx/op/unary.hpp>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct tan : unary
+{
+    std::string name() const { return "tan"; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/tanh.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_TANH_HPP
+#define MIGRAPHX_GUARD_OPERATORS_TANH_HPP
+
+#include <array>
+#include <migraphx/op/unary.hpp>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct tanh : unary
+{
+    std::string name() const { return "tanh"; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/transpose.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_TRANSPOSE_HPP
+#define MIGRAPHX_GUARD_OPERATORS_TRANSPOSE_HPP
+
+#include <array>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct transpose
+{
+    std::vector<int64_t> dims;
+
+    template <class Self, class F>
+    static auto reflect(Self& self, F f)
+    {
+        return pack(f(self.dims, "dims"));
+    }
+
+    std::string name() const { return "transpose"; }
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        check_shapes{inputs, *this}.has(1);
+        auto input         = inputs.at(0);
+        auto input_lens    = input.lens();
+        auto input_strides = input.strides();
+        auto t             = input.type();
+        if(dims.size() != input_lens.size())
+        {
+            MIGRAPHX_THROW("Permutation has wrong number of axes");
+        }
+        std::vector<int64_t> axes(dims.size());
+        std::iota(axes.begin(), axes.end(), 0);
+        if(!std::is_permutation(axes.begin(), axes.end(), dims.begin()))
+        {
+            MIGRAPHX_THROW("Invalid permutation");
+        }
+        std::vector<size_t> output_lens(input_lens.size());
+        std::vector<size_t> output_strides(input_lens.size());
+        for(std::size_t i = 0; i < output_lens.size(); i++)
+        {
+            output_lens[i]    = input_lens[dims[i]];
+            output_strides[i] = input_strides[dims[i]];
+        }
+        return {t, output_lens, output_strides};
+    }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        return {std::move(output_shape), std::move(args.front().data)};
+    }
+    int output_alias(const std::vector<shape>&) const { return 0; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/unary.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_UNARY_HPP
+#define MIGRAPHX_GUARD_OPERATORS_UNARY_HPP
+
+#include <array>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct unary
+{
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        check_shapes{inputs}.has(1);
+        return inputs.at(0);
+    }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/op/unsqueeze.hpp

+#ifndef MIGRAPHX_GUARD_OPERATORS_UNSQUEEZE_HPP
+#define MIGRAPHX_GUARD_OPERATORS_UNSQUEEZE_HPP
+
+#include <array>
+#include <migraphx/operation.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/stringutils.hpp>
+#include <migraphx/streamutils.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/config.hpp>
+#include <cmath>
+#include <utility>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+struct unsqueeze
+{
+    std::vector<int64_t> axes;
+
+    template <class Self, class F>
+    static auto reflect(Self& self, F f)
+    {
+        return pack(f(self.axes, "axes"));
+    }
+
+    std::string name() const { return "unsqueeze"; }
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        auto input_shape     = inputs[0];
+        auto type            = input_shape.type();
+        auto old_lens        = input_shape.lens();
+        std::size_t new_size = old_lens.size() + axes.size();
+        std::vector<std::size_t> new_lens(new_size);
+        std::size_t p = 0;
+        for(std::size_t i = 0; i < new_size; i++)
+        {
+            if(std::find(axes.begin(), axes.end(), i) != axes.end())
+            {
+                new_lens[i] = 1;
+            }
+            else
+            {
+                new_lens[i] = old_lens[p++];
+            }
+        }
+        return shape{type, new_lens};
+    }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        return {std::move(output_shape), std::move(args.front().data)};
+    }
+    int output_alias(const std::vector<shape>&) const { return 0; }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/operators.hpp

 #ifndef MIGRAPHX_GUARD_OPERATORS_HPP
 #define MIGRAPHX_GUARD_OPERATORS_HPP
 
-#include <array>
-#include <migraphx/operation.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
-#include <migraphx/config.hpp>
-#include <cmath>
-#include <utility>
-
-namespace migraphx {
-inline namespace MIGRAPHX_INLINE_NS {
-namespace op {
-
-enum padding_mode_t
-{
-    default_, // NOLINT
-    same,
-    valid
-};
-
-struct not_computable
-{
-    argument compute(const shape&, const std::vector<argument>&) const
-    {
-        MIGRAPHX_THROW("not computable");
-    }
-};
-
-struct batch_norm_inference
-{
-    float epsilon  = 1.0e-6f;
-    float momentum = 0.9f;
-
-    std::string name() const { return "batch_norm_inference"; }
-
-    enum bn_infer_mode_t
-    {
-        per_activation,
-        spatial,
-    };
-
-    bn_infer_mode_t bn_mode = spatial;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(
-            f(self.epsilon, "epsilon"), f(self.momentum, "momentum"), f(self.bn_mode, "bn_mode"));
-    }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(5);
-        return inputs.front();
-    }
-};
-
-struct lrn
-{
-    float alpha = 0.0001;
-    float beta  = 0.75;
-    float bias  = 1.0;
-    int size    = 1;
-    std::string name() const { return "lrn"; }
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.alpha, "alpha"),
-                    f(self.beta, "beta"),
-                    f(self.bias, "bias"),
-                    f(self.size, "size"));
-    }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        return inputs.front();
-    }
-};
-
-struct convolution
-{
-    std::array<std::size_t, 2> padding  = {{0, 0}};
-    std::array<std::size_t, 2> stride   = {{1, 1}};
-    std::array<std::size_t, 2> dilation = {{1, 1}};
-
-    padding_mode_t padding_mode = default_;
-    int group                   = 1;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.padding, "padding"),
-                    f(self.stride, "stride"),
-                    f(self.dilation, "dilation"),
-                    f(self.padding_mode, "padding_mode"),
-                    f(self.group, "group"));
-    }
-
-    std::string name() const { return "convolution"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(2).same_type().same_ndims().only_dims(4);
-
-        const shape& input   = inputs.at(0);
-        const shape& weights = inputs.at(1);
-        auto t               = input.type();
-        if(padding_mode == default_)
-        {
-            return {t,
-                    {
-                        input.lens()[0],
-                        weights.lens()[0],
-                        std::size_t(std::max<std::ptrdiff_t>(
-                            1,
-                            (input.lens()[2] - (1 + dilation[0] * (weights.lens()[2] - 1)) +
-                             2 * padding[0]) /
-                                    stride[0] +
-                                1)),
-                        std::size_t(std::max<std::ptrdiff_t>(
-                            1,
-                            (input.lens()[3] - (1 + dilation[1] * (weights.lens()[3] - 1)) +
-                             2 * padding[1]) /
-                                    stride[1] +
-                                1)),
-                    }};
-        }
-        else if(padding_mode == same)
-        {
-            return {t,
-                    {input.lens()[0],
-                     weights.lens()[0],
-                     static_cast<std::size_t>(
-                         std::ceil(static_cast<double>(input.lens()[2]) / stride[0])),
-                     static_cast<std::size_t>(
-                         std::ceil(static_cast<double>(input.lens()[3]) / stride[1]))}};
-        }
-        else if(padding_mode == valid)
-        {
-            return {
-                t,
-                {input.lens()[0],
-                 weights.lens()[0],
-                 static_cast<std::size_t>(std::ceil(
-                     static_cast<double>(input.lens()[2] - weights.lens()[2] + 1) / stride[0])),
-                 static_cast<std::size_t>(std::ceil(
-                     static_cast<double>(input.lens()[3] - weights.lens()[3] + 1) / stride[1]))}};
-        }
-        else
-        {
-            MIGRAPHX_THROW("Invalid padding mode");
-        }
-    }
-};
-
-struct im2col
-{
-    std::array<std::size_t, 2> padding  = {{0, 0}};
-    std::array<std::size_t, 2> stride   = {{1, 1}};
-    std::array<std::size_t, 2> dilation = {{1, 1}};
-
-    padding_mode_t padding_mode = default_;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.padding, "padding"),
-                    f(self.stride, "stride"),
-                    f(self.dilation, "dilation"),
-                    f(self.padding_mode, "padding_mode"));
-    }
-
-    std::string name() const { return "im2col"; }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto input          = inputs[0];
-        auto weights        = inputs[1];
-        auto batch_size     = input.lens()[0];
-        auto input_channels = weights.lens()[1];
-        auto kernel_height  = weights.lens()[2];
-        auto kernel_width   = weights.lens()[3];
-        check_shapes{inputs, *this}.has(2);
-        if(batch_size != 1)
-            MIGRAPHX_THROW("im2col only support batch_size 1");
-        auto output_height = std::size_t(std::max<std::ptrdiff_t>(
-            1,
-            (input.lens()[2] - (1 + dilation[0] * (kernel_height - 1)) + 2 * padding[0]) /
-                    stride[0] +
-                1));
-        auto output_width  = std::size_t(std::max<std::ptrdiff_t>(
-            1,
-            (input.lens()[3] - (1 + dilation[1] * (kernel_width - 1)) + 2 * padding[1]) /
-                    stride[1] +
-                1));
-        auto channels_col  = kernel_height * kernel_width * input_channels;
-        return {input.type(), {output_height * output_width, channels_col}};
-    }
-};
-
-struct pooling
-{
-    std::string mode                   = "average";
-    std::array<std::size_t, 2> padding = {{0, 0}};
-    std::array<std::size_t, 2> stride  = {{1, 1}};
-    std::array<std::size_t, 2> lengths = {{1, 1}};
-    padding_mode_t padding_mode        = default_;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.mode, "mode"),
-                    f(self.padding, "padding"),
-                    f(self.padding, "padding_mode"),
-                    f(self.stride, "stride"),
-                    f(self.lengths, "lengths"));
-    }
-
-    std::string name() const { return "pooling"; }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1).only_dims(4);
-
-        const shape& input = inputs.at(0);
-        auto t             = input.type();
-
-        assert(lengths[0] <= (input.lens()[2] + 2 * padding[0]));
-        assert(lengths[1] <= (input.lens()[3] + 2 * padding[1]));
-
-        if(padding_mode == default_)
-        {
-            return {
-                t,
-                {
-                    input.lens()[0],
-                    input.lens()[1],
-                    std::size_t(std::max<std::ptrdiff_t>(
-                        1,
-                        std::ptrdiff_t(std::floor((input.lens()[2] + 2 * padding[0] - lengths[0]) /
-                                                  static_cast<float>(stride[0]))) +
-                            1)),
-                    std::size_t(std::max<std::ptrdiff_t>(
-                        1,
-                        std::ptrdiff_t(std::floor((input.lens()[3] + 2 * padding[1] - lengths[1]) /
-                                                  static_cast<float>(stride[1]))) +
-                            1)),
-                }};
-        }
-        else if(padding_mode == same)
-        {
-            return {t,
-                    {input.lens()[0],
-                     input.lens()[1],
-                     static_cast<std::size_t>(
-                         std::ceil(static_cast<double>(input.lens()[2]) / stride[0])),
-                     static_cast<std::size_t>(
-                         std::ceil(static_cast<double>(input.lens()[3]) / stride[1]))}};
-        }
-        else if(padding_mode == valid)
-        {
-            return {t,
-                    {
-                        input.lens()[0],
-                        input.lens()[1],
-                        std::size_t(std::max<std::ptrdiff_t>(
-                            1,
-                            std::ptrdiff_t(std::floor((input.lens()[2] - lengths[0]) /
-                                                      static_cast<float>(stride[0]))) +
-                                1)),
-                        std::size_t(std::max<std::ptrdiff_t>(
-                            1,
-                            std::ptrdiff_t(std::floor((input.lens()[3] - lengths[1]) /
-                                                      static_cast<float>(stride[1]))) +
-                                1)),
-                    }};
-        }
-        else
-        {
-            MIGRAPHX_THROW("Invalid padding mode");
-        }
-    }
-};
-
-struct leaky_relu
-{
-    std::string name() const { return "leaky_relu"; }
-    float alpha;
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        return inputs.front();
-    }
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.alpha, "alpha"));
-    }
-};
-
-struct elu
-{
-    std::string name() const { return "elu"; }
-    float alpha;
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        return inputs.front();
-    }
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.alpha, "alpha"));
-    }
-};
-
-struct transpose
-{
-    std::vector<int64_t> dims;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.dims, "dims"));
-    }
-
-    std::string name() const { return "transpose"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto input         = inputs.at(0);
-        auto input_lens    = input.lens();
-        auto input_strides = input.strides();
-        auto t             = input.type();
-        if(dims.size() != input_lens.size())
-        {
-            MIGRAPHX_THROW("Permutation has wrong number of axes");
-        }
-        std::vector<int64_t> axes(dims.size());
-        std::iota(axes.begin(), axes.end(), 0);
-        if(!std::is_permutation(axes.begin(), axes.end(), dims.begin()))
-        {
-            MIGRAPHX_THROW("Invalid permutation");
-        }
-        std::vector<size_t> output_lens(input_lens.size());
-        std::vector<size_t> output_strides(input_lens.size());
-        for(std::size_t i = 0; i < output_lens.size(); i++)
-        {
-            output_lens[i]    = input_lens[dims[i]];
-            output_strides[i] = input_strides[dims[i]];
-        }
-        return {t, output_lens, output_strides};
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.front().data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-/// The contiguous operator takes a non-standard input tensor and returns
-/// the same tensor but in standard form. For example, if input tensor A which has lens = (4,5)
-/// is first transposed, i.e. lens = (5,4), this tensor's data layout remained the same
-/// during the transpose operation; only it's shape lengths and strides were changed.
-/// This leaves the tensor in a non-standard form. The contiguous operator copies the
-/// underlying data such that resulting tensor is returned to a standard form.
-struct contiguous
-{
-    std::string name() const { return "contiguous"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto lens = inputs.at(0).lens();
-        auto t    = inputs.at(0).type();
-        return {t, lens};
-    }
-    argument compute(const shape& output_shape, std::vector<argument> args) const
-    {
-        assert(output_shape.standard());
-        argument result{output_shape};
-        visit_all(result, args[0])([&](auto output, auto input) {
-            shape_for_each(output.get_shape(), [&](const auto& idx) {
-                output(idx.begin(), idx.end()) = input(idx.begin(), idx.end());
-            });
-        });
-        return result;
-    }
-};
-
-struct concat
-{
-    std::size_t axis = 0;
-    std::string name() const { return "concat"; }
-    std::vector<std::size_t> compute_offsets(const shape& output_shape,
-                                             const std::vector<argument>& args) const
-    {
-        std::vector<std::size_t> offsets;
-        std::vector<std::size_t> offset(args[0].get_shape().lens().size(), 0);
-        offset[axis] = 0;
-        for(const auto& arg : args)
-        {
-            offsets.push_back(output_shape.index(offset));
-            offset[axis] += arg.get_shape().lens()[axis];
-        }
-        return offsets;
-    }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        if(inputs.empty())
-        {
-            MIGRAPHX_THROW("Number of input tensors should exceed 0");
-        }
-
-        const auto& first_shape_lens = inputs.front().lens();
-        const auto& type             = inputs.front().type();
-        for(std::size_t l = 0; l < first_shape_lens.size(); l++)
-        {
-            if(l != axis)
-            {
-                if(!std::all_of(inputs.begin(), inputs.end(), [&](auto s) {
-                       return s.lens()[l] == first_shape_lens[l];
-                   }))
-                {
-                    MIGRAPHX_THROW("Non-axis dimensions should match");
-                }
-            }
-        }
-        std::size_t new_dim_axis = 0;
-        for(const auto& input : inputs)
-        {
-            const auto& lens = input.lens();
-            new_dim_axis += lens[axis];
-        }
-        std::vector<std::size_t> new_lens;
-        std::copy(first_shape_lens.begin(), first_shape_lens.end(), std::back_inserter(new_lens));
-        new_lens[axis] = new_dim_axis;
-        return {type, new_lens};
-    }
-    argument compute(const shape& output_shape, std::vector<argument> args) const
-    {
-        argument result{output_shape};
-        std::vector<std::size_t> coffsets = compute_offsets(output_shape, args);
-        for(std::size_t l = 0; l < args.size(); l++)
-        {
-            auto argl             = args[l];
-            std::size_t nelements = argl.get_shape().elements();
-            visit_all(result, argl)([&](auto output, auto input) {
-                auto slice_shape =
-                    shape{output_shape.type(), input.get_shape().lens(), output_shape.strides()};
-                auto slice = make_view(slice_shape, output.data() + coffsets[l]);
-                // cppcheck-suppress useStlAlgorithm
-                for(std::size_t i = 0; i < nelements; i++)
-                {
-                    slice[i] = input[i];
-                }
-            });
-        }
-        return result;
-    }
-};
-
-struct slice
-{
-    std::vector<int64_t> axes;
-    std::vector<int64_t> starts;
-    std::vector<int64_t> ends;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.axes, "axes"), f(self.starts, "starts"), f(self.ends, "ends"));
-    }
-
-    std::string name() const { return "slice"; }
-
-    auto fix_index(const std::vector<std::size_t>& lens, std::size_t axis, int64_t index) const
-    {
-        int64_t r = std::min(index, static_cast<int64_t>(lens[axis]));
-        if(r < 0)
-            r += lens[axis];
-        return std::size_t(r);
-    }
-
-    auto compute_offset(const shape& s) const
-    {
-        const std::vector<std::size_t>& lens    = s.lens();
-        const std::vector<std::size_t>& strides = s.strides();
-        auto offset                             = 0;
-        if(!axes.empty())
-        {
-            for(std::size_t i = 0; i < axes.size(); i++)
-            {
-                auto axis = axes[i];
-                offset += fix_index(lens, axis, starts[i]) * strides[axis];
-            }
-        }
-        else
-        {
-            for(std::size_t axis = 0; axis < lens.size(); axis++)
-            {
-                offset += fix_index(lens, axis, starts[axis]) * strides[axis];
-            }
-        }
-        return offset;
-    }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto input_shape        = inputs[0];
-        auto t                  = input_shape.type();
-        const auto& old_lens    = input_shape.lens();
-        const auto& old_strides = input_shape.strides();
-        if(starts.size() != axes.size() || axes.size() != ends.size())
-        {
-            MIGRAPHX_THROW("inconsistent sizes");
-        }
-        std::vector<std::size_t> new_lens = old_lens;
-        for(std::size_t i = 0; i < axes.size(); i++)
-        {
-            auto axis = axes[i];
-            new_lens[axis] =
-                fix_index(old_lens, axis, ends[i]) - fix_index(old_lens, axis, starts[i]);
-        }
-        return shape{t, new_lens, old_strides};
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        auto input  = args[0];
-        auto offset = compute_offset(input.get_shape()) * output_shape.type_size();
-        return {std::move(output_shape), [=] { return input.data() + offset; }};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct squeeze
-{
-    std::vector<int64_t> axes;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.axes, "axes"));
-    }
-
-    std::string name() const { return "squeeze"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto input_shape = inputs[0];
-        auto type        = input_shape.type();
-        auto old_lens    = input_shape.lens();
-        if(std::any_of(
-               axes.begin(), axes.end(), [&](auto axis) { return input_shape.lens()[axis] != 1; }))
-        {
-            MIGRAPHX_THROW("squeeze axis dimension should be equal to 1");
-        }
-        std::vector<std::size_t> new_lens;
-        if(axes.empty())
-        {
-            std::copy_if(old_lens.begin(),
-                         old_lens.end(),
-                         std::back_inserter(new_lens),
-                         [](auto len) { return len != 1; });
-        }
-        else
-        {
-            for(std::size_t i = 0; i < old_lens.size(); i++)
-            {
-                if(std::find(axes.begin(), axes.end(), i) == axes.end())
-                {
-                    new_lens.push_back(old_lens[i]);
-                }
-            }
-        }
-        return shape{type, new_lens};
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.front().data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct unsqueeze
-{
-    std::vector<int64_t> axes;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.axes, "axes"));
-    }
-
-    std::string name() const { return "unsqueeze"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto input_shape     = inputs[0];
-        auto type            = input_shape.type();
-        auto old_lens        = input_shape.lens();
-        std::size_t new_size = old_lens.size() + axes.size();
-        std::vector<std::size_t> new_lens(new_size);
-        std::size_t p = 0;
-        for(std::size_t i = 0; i < new_size; i++)
-        {
-            if(std::find(axes.begin(), axes.end(), i) != axes.end())
-            {
-                new_lens[i] = 1;
-            }
-            else
-            {
-                new_lens[i] = old_lens[p++];
-            }
-        }
-        return shape{type, new_lens};
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.front().data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct reshape
-{
-    std::vector<int64_t> dims;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.dims, "dims"));
-    }
-
-    std::string name() const { return "reshape"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto&& idims = inputs.front().lens();
-        std::vector<std::size_t> rdims(dims.begin(), dims.end());
-        auto n_neg_dims = std::count(dims.begin(), dims.end(), -1);
-        if(n_neg_dims > 1)
-            MIGRAPHX_THROW("Dimensions for reshape can only have one -1 dim");
-        for(std::size_t i = 0; i < dims.size(); i++)
-        {
-            if(dims[i] == 0)
-                rdims[i] = idims[i];
-
-            // since rdims using size_t type, -1 is the max value
-            // is size_t that cause later compuation incorrect
-            if(dims[i] == -1)
-                rdims[i] = 1;
-        }
-        if(n_neg_dims > 0)
-        {
-            size_t missing_dim =
-                inputs.front().elements() /
-                std::accumulate(rdims.begin(), rdims.end(), 1, std::multiplies<int64_t>());
-            for(std::size_t i = 0; i < rdims.size(); i++)
-            {
-                if(dims[i] == -1)
-                    rdims[i] = missing_dim;
-            }
-        }
-
-        shape s{inputs.front().type(), rdims};
-        if(s.elements() != inputs.front().elements())
-            MIGRAPHX_THROW("Wrong number of elements for reshape");
-        return s;
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.front().data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct pad
-{
-    std::vector<int64_t> pads;
-    float value = 0.0f;
-    enum pad_op_mode_t
-    {
-        constant_pad,
-        reflect_pad,
-        edge_pad
-    };
-    pad_op_mode_t mode = constant_pad;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.mode, "mode"), f(self.pads, "pads"), f(self.value, "value"));
-    }
-
-    std::string name() const { return "pad"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto&& idims = inputs.front().lens();
-        std::vector<std::size_t> rdims(idims.begin(), idims.end());
-        std::size_t num_dims = rdims.size();
-
-        for(std::size_t i = 0; i < num_dims; i++)
-        {
-            rdims[i] += pads[i] + pads[i + num_dims];
-        }
-
-        shape s{inputs.front().type(), rdims};
-        return s;
-    }
-};
-
-struct as_shape
-{
-    shape s;
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.s, "shape"));
-    }
-
-    std::string name() const { return "as_shape"; }
-    shape compute_shape(const std::vector<shape>& inputs) const
-    {
-        check_shapes{inputs, *this}.has(1).standard();
-        assert(inputs.front().elements() == s.elements());
-        return s;
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.front().data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct gather
-{
-    int axis = 0;
-    std::string name() const { return "gather"; }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(2);
-        auto lens = inputs[0].lens();
-        int n_dim = static_cast<int>(lens.size());
-        if(axis >= n_dim || axis < -n_dim)
-        {
-            MIGRAPHX_THROW("Gather: axis is out of range.");
-        }
-
-        // negative axis means counting dimensions from back
-        int axis_index = (axis < 0) ? (n_dim + axis) : axis;
-
-        auto type = inputs[0].type();
-        lens.erase(lens.begin() + axis_index);
-        if(!inputs[1].scalar())
-        {
-            auto ind_lens = inputs[1].lens();
-            lens.insert(lens.begin() + axis_index, ind_lens.begin(), ind_lens.end());
-        }
-
-        // for scalar output
-        if(lens.empty())
-        {
-            return {type};
-        }
-
-        return {type, lens};
-    }
-
-    argument compute(const shape& output_shape, std::vector<argument> args) const
-    {
-        argument result{output_shape};
-        // negative axis means counting dimensions from back
-        int axis_index =
-            (axis < 0) ? static_cast<int>(args[0].get_shape().lens().size() + axis) : axis;
-
-        // max dimension in axis
-        visit_all(result, args[0])([&](auto output, auto data) {
-            args[1].visit([&](auto indices) {
-                if(output_shape.scalar())
-                {
-                    output[0] = data[indices.front()];
-                }
-                else
-                {
-                    auto out_lens        = data.get_shape().lens();
-                    out_lens[axis_index] = indices.get_shape().elements();
-                    migraphx::shape out_comp_shape{data.get_shape().type(), out_lens};
-                    shape_for_each(out_comp_shape, [&](const auto& out_idx) {
-                        auto data_idx        = out_idx;
-                        data_idx[axis_index] = indices[data_idx[axis_index]];
-                        output[out_comp_shape.index(out_idx.begin(), out_idx.end())] =
-                            data(data_idx.begin(), data_idx.end());
-                    });
-                }
-            });
-        });
-
-        return result;
-    }
-};
-
-// The dot operation is combination of the onnx GEMM and MatMul operators.
-// For GEMM, it support two cases: 1) in the formula alpha * AB + beta * C,
-// A and B are 2-D matrics and C is broadcastable to the shape of A*B. For
-// the transpose of A and B, we add a tranpose operator beforehand if the
-// onnx gemm operator indicates a transpose required. 2) A and B are more
-// than 2-D, then the dims except the last 2-D in A and B need to be the
-// same, and C should be the same shape as A * B
-// For MatMul, it has the same definition as the numpy.matmul, which means
-// A, B could be 1 to N-dims. For 1-dim input of A, it is a vector * matrix,
-// for 1-dim of B, it is a matrix * vector. Note that there is not support
-// of batch of 1-dim vector. In another word, if A or B is 1-dim, it is a
-// vector input; if A or B is 2-dim, it is a matrix (no case of a batch of
-// vectors as input). If A or B is 3 or more dims, it is considered as a
-// stack(batch) of matrices.
-// Note that we only support the scenario of either the Matmul or Gemm
-// operators. That is, if there are 3 inputs, we consider it is a Gemm, then
-// A and B must be matrix inputs, and C is broadcastable to A * B. If there
-// is only two inputs, A and B can be 1-dim to N-dim, in this case, there
-// is no C input.
-struct dot
-{
-    float alpha = 1.0;
-    float beta  = 1.0;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.alpha, "alpha"), f(self.beta, "beta"));
-    }
-
-    // if not a multi_broadcast, b should be broadcastable to a
-    std::vector<std::size_t> shape_broadcast(std::vector<std::size_t>& a,
-                                             std::vector<std::size_t>& b,
-                                             bool is_mutli_broadcast = true) const
-    {
-        if(b.empty())
-            return a;
-
-        if(a.empty())
-        {
-            return b;
-        }
-
-        auto a_size = a.size();
-        auto b_size = b.size();
-
-        auto n_dim = std::min(a_size, b_size);
-        std::vector<std::size_t> out_lens(std::max(a_size, b_size));
-        for(std::size_t i = 0; i < n_dim; ++i)
-        {
-            if(a[a_size - 1 - i] == b[b_size - 1 - i])
-            {
-                out_lens[i] = a[a_size - 1 - i];
-            }
-            else if(b[b_size - 1 - i] == 1)
-            {
-                out_lens[i] = a[a_size - 1 - i];
-            }
-            else if(a[a_size - 1 - i] == 1 && is_mutli_broadcast)
-            {
-                out_lens[i] = b[b_size - 1 - i];
-            }
-            else
-            {
-                MIGRAPHX_THROW("DOT : dimension mismatch, matrix A: {" + to_string_range(a) +
-                               "}, and matrix B: {" + to_string_range(b) +
-                               "} are not broadcastable");
-            }
-        }
-
-        if(a_size > n_dim)
-        {
-            std::copy(a.rbegin() + n_dim, a.rend(), out_lens.begin() + n_dim);
-        }
-
-        if(b_size > n_dim)
-        {
-            std::copy(b.rbegin() + n_dim, b.rend(), out_lens.begin() + n_dim);
-        }
-
-        std::reverse(out_lens.begin(), out_lens.end());
-
-        return out_lens;
-    }
-
-    std::string name() const { return "dot"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        // If there are 3 inputs, there are two scenarios:
-        // 1. A and B are 2-D matrices and C is broadcastable to A * B
-        // 2. A and B are stack of matrices, then shape for the batch
-        // should be the same for A and B, and C is the same shape
-        // as A * B (For now, we add this requirement to simplify the
-        // implementation. we can remove this requirement later)
-        if(inputs.size() == 3)
-        {
-            auto a_lens   = inputs[0].lens();
-            auto b_lens   = inputs[1].lens();
-            auto out_lens = a_lens;
-            auto t        = inputs[0].type();
-            if(inputs[1].lens().size() > 2)
-            {
-                if(!std::equal(a_lens.rbegin() + 2, a_lens.rend(), b_lens.rbegin() + 2))
-                {
-                    MIGRAPHX_THROW("DOT: dimension mismatch, operand A: {" +
-                                   to_string_range(a_lens) + "}, cannot multiply operand B: {" +
-                                   to_string_range(b_lens) + "}");
-                }
-
-                std::size_t dim_0 = a_lens.size() - 2;
-                std::size_t dim_1 = a_lens.size() - 1;
-                if(a_lens[dim_1] != b_lens[dim_0])
-                    MIGRAPHX_THROW("DOT: inner dimensions do not match, operand A: {" +
-                                   to_string_range(a_lens) + "}, operand B: {" +
-                                   to_string_range(b_lens) + "}");
-                out_lens[dim_1] = b_lens[dim_1];
-
-                // C should be the same shape as A * B
-                auto c_lens = inputs[2].lens();
-                if(!std::equal(out_lens.begin(), out_lens.end(), c_lens.begin()))
-                {
-                    MIGRAPHX_THROW("DOT: dimension mismatch, operand C: {" +
-                                   to_string_range(c_lens) + "}, cannot add to operand A * B: {" +
-                                   to_string_range(out_lens) + "}");
-                }
-            }
-            else
-            {
-                check_shapes{inputs, *this}.has(3).same_type();
-                check_shapes{{inputs[0]}, *this}.only_dims(2);
-                check_shapes{{inputs[1]}, *this}.only_dims(2);
-
-                if(a_lens[1] != b_lens[0])
-                {
-                    MIGRAPHX_THROW("DOT : dimension mismatch, operand A: {" +
-                                   to_string_range(a_lens) + "}, cannot multiply operand B: {" +
-                                   to_string_range(b_lens) + "}");
-                }
-
-                out_lens[1] = b_lens[1];
-
-                // check whether C is broadcastable to A * B
-                auto c_lens = inputs[2].lens();
-                if(c_lens.size() > 2 ||
-                   (c_lens.size() == 1 && (c_lens[0] != 1 && c_lens[0] != b_lens[1])) ||
-                   (c_lens.size() == 2 && (c_lens[0] != 1 && c_lens[0] != a_lens[0])) ||
-                   (c_lens.size() == 2 && (c_lens[1] != 1 && c_lens[1] != b_lens[1])))
-                {
-                    MIGRAPHX_THROW("DOT: C {" + to_string_range(c_lens) +
-                                   "} is not broadcastable to A * B {" + to_string_range(out_lens) +
-                                   "}");
-                }
-            }
-
-            return {t, out_lens};
-        }
-
-        // For the case of two inputs, it is the numpy.matmul
-        check_shapes{inputs, *this}.has(2).same_type();
-        const shape& a = inputs.at(0);
-        const shape& b = inputs.at(1);
-        auto t         = a.type();
-
-        if(a.scalar() || b.scalar())
-        {
-            MIGRAPHX_THROW("DOT: scalar operands are not allowed, use op::mul{} instead");
-        }
-
-        auto a_lens        = a.lens();
-        auto b_lens        = b.lens();
-        bool is_a_appended = false;
-        bool is_b_appended = false;
-
-        if(a_lens.size() == 1)
-        {
-            a_lens.insert(a_lens.begin(), 1);
-            is_a_appended = true;
-        }
-
-        if(b_lens.size() == 1)
-        {
-            b_lens.push_back(1);
-            is_b_appended = true;
-        }
-
-        std::size_t dim_1 = a_lens.size() - 1;
-        std::size_t dim_0 = b_lens.size() - 2;
-        if(a_lens[dim_1] != b_lens[dim_0])
-        {
-            MIGRAPHX_THROW("DOT : dimension mismatch, operand A: {" + to_string_range(a.lens()) +
-                           "}, cannot multiply operand B: {" + to_string_range(b.lens()) + "}");
-        }
-
-        // remove the matrix dims, do multi_broadcast of the shape of the batch
-        a_lens.pop_back();
-        std::size_t out_m = a_lens.back();
-        a_lens.pop_back();
-
-        std::size_t out_n = b_lens.back();
-        b_lens.pop_back();
-        b_lens.pop_back();
-
-        auto out_lens = shape_broadcast(a_lens, b_lens);
-        out_lens.push_back(out_m);
-        out_lens.push_back(out_n);
-
-        // remove the prepended 1, if a is a vector
-        if(is_a_appended)
-        {
-            out_lens.erase(out_lens.begin() + out_lens.size() - 2);
-        }
-
-        // remove the appended 1, if b is a vector
-        if(is_b_appended)
-        {
-            out_lens.pop_back();
-        }
-
-        if(out_lens.empty())
-        {
-            return {t};
-        }
-        else
-        {
-            return {t, out_lens};
-        }
-    }
-};
-
-struct unary
-{
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs}.has(1);
-        return inputs.at(0);
-    }
-};
-
-struct identity
-{
-    std::string name() const { return "identity"; }
-    shape compute_shape(std::vector<shape> inputs) const { return inputs.at(0); }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.at(0).data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct abs : unary
-{
-    std::string name() const { return "abs"; }
-};
-
-struct exp : unary
-{
-    std::string name() const { return "exp"; }
-};
-
-struct log : unary
-{
-    std::string name() const { return "log"; }
-};
-
-struct sin : unary
-{
-    std::string name() const { return "sin"; }
-};
-
-struct cos : unary
-{
-    std::string name() const { return "cos"; }
-};
-
-struct tan : unary
-{
-    std::string name() const { return "tan"; }
-};
-
-struct asin : unary
-{
-    std::string name() const { return "asin"; }
-};
-
-struct acos : unary
-{
-    std::string name() const { return "acos"; }
-};
-
-struct atan : unary
-{
-    std::string name() const { return "atan"; }
-};
-
-struct sinh : unary
-{
-    std::string name() const { return "sinh"; }
-};
-
-struct cosh : unary
-{
-    std::string name() const { return "cosh"; }
-};
-
-struct tanh : unary
-{
-    std::string name() const { return "tanh"; }
-};
-
-struct sigmoid : unary
-{
-    std::string name() const { return "sigmoid"; }
-};
-
-struct neg : unary
-{
-    std::string name() const { return "neg"; }
-};
-
-struct relu : unary
-{
-    std::string name() const { return "relu"; }
-};
-
-struct softmax
-{
-    std::string name() const { return "softmax"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs}.has(1).only_dims(4);
-        return inputs.at(0);
-    }
-};
-
-struct logsoftmax
-{
-    int axis = 1;
-    std::string name() const { return "logsoftmax"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs}.has(1);
-        if(axis < 0 || axis > inputs[0].lens().size())
-        {
-            MIGRAPHX_THROW("LogSoftMax: input axis value " + std::to_string(axis) +
-                           " is out of range");
-        }
-        return inputs.at(0);
-    }
-};
-
-struct flatten
-{
-    uint64_t axis = 0;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.axis, "axis"));
-    }
-
-    std::string name() const { return "flatten"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs}.has(1);
-        auto&& lens = inputs.front().lens();
-
-        if(axis > lens.size())
-        {
-            MIGRAPHX_THROW("axis for flatten must be less than tensor rank");
-        }
-        auto x =
-            std::accumulate(lens.begin(), lens.begin() + axis, std::size_t{1}, std::multiplies<>{});
-        auto y =
-            std::accumulate(lens.begin() + axis, lens.end(), std::size_t{1}, std::multiplies<>{});
-        return {inputs.at(0).type(), {x, y}};
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.front().data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-/// The broadcast operator performs the numpy-style broadcasting of an axis of a given tensor. This
-/// is achieved primarily by setting the stride of the broadcasted axis to zero. Linear indicies are
-/// computed from multi-indicies by computing the inner product on the multi-index with the strides.
-/// For example, if we have a tensor A(2,3) it has lengths of (2,3) and strides of (3,1). If we want
-/// to compute the linear offset that corresponds to the element on the 2nd row (i = 1) and 3rd
-/// column (j = 2), we compute the following inner product (1,2) dot (3, 1) = 1*3 + 2*1 = 5. It is
-/// obvious from there that we can negate the effects of a given axis by setting the stride of that
-/// axis to zero.
-struct broadcast
-{
-    uint64_t axis = 0;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.axis, "axis"));
-    }
-
-    shape broadcast_shape;
-    std::string name() const { return "broadcast"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto t     = inputs.at(0).type();
-        auto input = inputs.at(0);
-
-        std::vector<size_t> bcast_strides(broadcast_shape.lens().size(), 0);
-
-        if(std::all_of(broadcast_shape.lens().cbegin(), broadcast_shape.lens().cend(), [&](auto x) {
-               return x == 1;
-           }))
-        {
-            if(axis != 0)
-                MIGRAPHX_THROW("when broadcasting tensor of size 1, axis should be 0");
-            return {t, broadcast_shape.lens(), std::move(bcast_strides)};
-        }
-        else
-        {
-            assert(broadcast_shape.lens().size() - axis >= input.lens().size());
-            if(!std::equal(
-                   input.lens().begin(), input.lens().end(), broadcast_shape.lens().begin() + axis))
-                MIGRAPHX_THROW("when broadcasting success sizes must match");
-            std::copy(input.strides().begin(), input.strides().end(), bcast_strides.begin() + axis);
-            return {t, broadcast_shape.lens(), std::move(bcast_strides)};
-        }
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.at(0).data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct multibroadcast
-{
-    std::vector<std::size_t> output_lens;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.output_lens, "output_lens"));
-    }
-
-    std::string name() const { return "multibroadcast"; }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto t     = inputs.at(0).type();
-        auto input = inputs.at(0);
-
-        if(input.lens().empty())
-            MIGRAPHX_THROW("inputs dimensions should be > 0");
-
-        if(input.lens().size() > output_lens.size())
-            MIGRAPHX_THROW("inputs dimensions should <= output size");
-
-        std::vector<size_t> bcast_strides(output_lens.size(), 0);
-        auto offset = output_lens.size() - input.lens().size();
-        for(int i = input.lens().size() - 1; i >= 0; i--)
-        {
-            if(output_lens[i + offset] == input.lens()[i])
-            {
-                bcast_strides[i + offset] = input.strides()[i];
-            }
-        }
-        return {t, output_lens, bcast_strides};
-    }
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.at(0).data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct scalar
-{
-    shape scalar_bcast;
-
-    std::string name() const { return "scalar"; }
-
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        assert(check_shapes{inputs}.has(1).only_dims(1).size() == 1);
-        auto t = inputs.at(0).type();
-        std::vector<std::size_t> strides(scalar_bcast.lens().size(), 0);
-        return {t, scalar_bcast.lens(), strides};
-    }
-
-    argument compute(shape output_shape, std::vector<argument> args) const
-    {
-        return {std::move(output_shape), std::move(args.at(0).data)};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-};
-
-struct binary
-{
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs}.has(2).same_type().same_dims();
-        auto t    = inputs.at(0).type();
-        auto lens = inputs.at(0).lens();
-        return {t, lens};
-    }
-};
-
-struct add : binary
-{
-    std::string name() const { return "add"; }
-};
-
-struct sub : binary
-{
-    std::string name() const { return "sub"; }
-};
-
-struct mul : binary
-{
-    std::string name() const { return "mul"; }
-};
-
-struct div : binary
-{
-    std::string name() const { return "div"; }
-};
-
-struct max : binary
-{
-    std::string name() const { return "max"; }
-};
-
-struct min : binary
-{
-    std::string name() const { return "min"; }
-};
-
-struct load
-{
-    shape s;
-    std::size_t offset = 0;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.s, "shape"), f(self.offset, "offset"));
-    }
-
-    std::string name() const { return "load"; }
-    shape compute_shape(const std::vector<shape>& inputs) const
-    {
-        check_shapes{inputs}.has(1);
-        return s;
-    }
-    argument compute(const shape&, const std::vector<argument>& args) const
-    {
-        if((offset + s.bytes()) > args[0].get_shape().bytes())
-            MIGRAPHX_THROW("Load access is out of bounds");
-        return {s, args[0].data() + offset};
-    }
-    int output_alias(const std::vector<shape>&) const { return 0; }
-
-    friend std::ostream& operator<<(std::ostream& os, const load& op)
-    {
-        os << op.name() << "[";
-        os << "offset=" << op.offset << ",";
-        os << "end=" << (op.offset + op.s.bytes()) << "]";
-        return os;
-    }
-};
-
-struct outline
-{
-    shape s;
-
-    template <class Self, class F>
-    static auto reflect(Self& self, F f)
-    {
-        return pack(f(self.s, "shape"));
-    }
-
-    std::string name() const { return "outline"; }
-    shape compute_shape(const std::vector<shape>& inputs) const
-    {
-        check_shapes{inputs, *this}.has(0);
-        return s;
-    }
-    argument compute(const shape&, const std::vector<argument>&) const { return {s, nullptr}; }
-};
-
-// indicate rnn computation direction
-enum class rnn_direction
-{
-    forward,
-    reverse,
-    bidirectional,
-};
-
-struct rnn
-{
-    std::size_t hidden_size = 1;
-    std::vector<operation> actv_funcs{tanh{}, tanh{}};
-    rnn_direction direction = rnn_direction::forward;
-    float clip              = 0.0f;
-
-    std::string name() const { return "rnn"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto in_dims     = inputs[0].lens();
-        auto hidden_dims = inputs[2].lens();
-        if(hidden_size != hidden_dims[2])
-        {
-            MIGRAPHX_THROW("RNN: hidden size mismatch in attribute and input");
-        }
-
-        std::size_t num_directions = 1;
-        if(direction == rnn_direction::bidirectional)
-        {
-            num_directions = 2;
-        }
-
-        if(num_directions != hidden_dims[0])
-        {
-            MIGRAPHX_THROW("RNN: num_direction mismatch in attribute and input");
-        }
-
-        std::vector<std::size_t> out_dims(in_dims);
-        out_dims.insert(out_dims.begin() + 1, num_directions);
-        out_dims.back() = hidden_size;
-
-        return {inputs[0].type(), out_dims};
-    }
-};
-
-struct rnn_last_output
-{
-    std::string name() const { return "rnn_last_output"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto dims = inputs[0].lens();
-
-        // remove the first dimension, remaing are output shape
-        dims.erase(dims.begin());
-        return {inputs[0].type(), dims};
-    }
-};
-
-struct gru
-{
-    std::size_t hidden_size = 1;
-    std::vector<operation> actv_funcs{sigmoid{}, tanh{}};
-    rnn_direction direction = rnn_direction::forward;
-    float clip              = 0.0f;
-    int linear_before_reset = 0;
-
-    std::string name() const { return "gru"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto in_dims     = inputs[0].lens();
-        auto hidden_dims = inputs[2].lens();
-        if(hidden_size != hidden_dims[2])
-        {
-            MIGRAPHX_THROW("GRU: hidden size mismatch in attribute and input");
-        }
-
-        std::size_t num_directions = 1;
-        if(direction == rnn_direction::bidirectional)
-        {
-            num_directions = 2;
-        }
-
-        if(num_directions != hidden_dims[0])
-        {
-            MIGRAPHX_THROW("GRU: num_direction does not match the direction attribute");
-        }
-
-        std::vector<std::size_t> out_dims(in_dims);
-        out_dims.insert(out_dims.begin() + 1, num_directions);
-        out_dims.back() = hidden_size;
-
-        return {inputs[0].type(), out_dims};
-    }
-};
-
-struct lstm
-{
-    std::size_t hidden_size = 1;
-    std::vector<operation> actv_funcs{sigmoid{}, tanh{}, tanh{}};
-    rnn_direction direction = rnn_direction::forward;
-    float clip              = 0.0f;
-    int input_forget        = 0;
-
-    std::string name() const { return "lstm"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        auto in_dims     = inputs[0].lens();
-        auto hidden_dims = inputs[2].lens();
-        if(hidden_size != hidden_dims[2])
-        {
-            MIGRAPHX_THROW("LSTM: hidden size mismatch in attribute and input");
-        }
-
-        std::size_t num_directions = 1;
-        if(direction == rnn_direction::bidirectional)
-        {
-            num_directions = 2;
-        }
-
-        if(num_directions != hidden_dims[0])
-        {
-            MIGRAPHX_THROW("LSTM: num_direction does not match the direction attribute");
-        }
-
-        std::vector<std::size_t> out_dims(in_dims);
-        out_dims.insert(out_dims.begin() + 1, num_directions);
-        out_dims.back() = hidden_size;
-
-        return {inputs[0].type(), out_dims};
-    }
-};
-
-struct lstm_last_cell_output
-{
-    std::string name() const { return "lstm_last_cell_output"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        check_shapes{inputs, *this}.has(1);
-        auto dims = inputs[0].lens();
-
-        // remove the first dimension, remaing are output shape
-        dims.erase(dims.begin());
-        return {inputs[0].type(), dims};
-    }
-};
-
-struct undefined
-{
-    std::string name() const { return "undefined"; }
-    shape compute_shape(const std::vector<shape>& inputs) const
-    {
-        check_shapes{inputs, *this}.has(0);
-        return {};
-    }
-
-    argument compute(const shape&, const std::vector<argument>&) const { return {{}, nullptr}; }
-};
-
-struct unknown
-{
-    std::string op;
-    std::string name() const { return "unknown:" + op; }
-    shape compute_shape(std::vector<shape> input) const
-    {
-        if(input.empty())
-            return {};
-        else
-            return input.front();
-    }
-
-    friend std::ostream& operator<<(std::ostream& os, const unknown& x)
-    {
-        os << x.name();
-        return os;
-    }
-};
-
-} // namespace op
-} // namespace MIGRAPHX_INLINE_NS
-} // namespace migraphx
+#include <migraphx/op/abnormal_ops.hpp>
+#include <migraphx/op/abs.hpp>
+#include <migraphx/op/acos.hpp>
+#include <migraphx/op/add.hpp>
+#include <migraphx/op/asin.hpp>
+#include <migraphx/op/as_shape.hpp>
+#include <migraphx/op/atan.hpp>
+#include <migraphx/op/batch_norm.hpp>
+#include <migraphx/op/binary.hpp>
+#include <migraphx/op/broadcast.hpp>
+#include <migraphx/op/common.hpp>
+#include <migraphx/op/concat.hpp>
+#include <migraphx/op/contiguous.hpp>
+#include <migraphx/op/convolution.hpp>
+#include <migraphx/op/cosh.hpp>
+#include <migraphx/op/cos.hpp>
+#include <migraphx/op/div.hpp>
+#include <migraphx/op/dot.hpp>
+#include <migraphx/op/elu.hpp>
+#include <migraphx/op/exp.hpp>
+#include <migraphx/op/flatten.hpp>
+#include <migraphx/op/gather.hpp>
+#include <migraphx/op/gru.hpp>
+#include <migraphx/op/identity.hpp>
+#include <migraphx/op/im2col.hpp>
+#include <migraphx/op/leaky_relu.hpp>
+#include <migraphx/op/load.hpp>
+#include <migraphx/op/log.hpp>
+#include <migraphx/op/logsoftmax.hpp>
+#include <migraphx/op/lrn.hpp>
+#include <migraphx/op/lstm.hpp>
+#include <migraphx/op/max.hpp>
+#include <migraphx/op/min.hpp>
+#include <migraphx/op/mul.hpp>
+#include <migraphx/op/multibroadcast.hpp>
+#include <migraphx/op/neg.hpp>
+#include <migraphx/op/outline.hpp>
+#include <migraphx/op/pad.hpp>
+#include <migraphx/op/pooling.hpp>
+#include <migraphx/op/relu.hpp>
+#include <migraphx/op/reshape.hpp>
+#include <migraphx/op/rnn.hpp>
+#include <migraphx/op/rnn_last_cell_output.hpp>
+#include <migraphx/op/rnn_last_output.hpp>
+#include <migraphx/op/scalar.hpp>
+#include <migraphx/op/sigmoid.hpp>
+#include <migraphx/op/sinh.hpp>
+#include <migraphx/op/sin.hpp>
+#include <migraphx/op/slice.hpp>
+#include <migraphx/op/softmax.hpp>
+#include <migraphx/op/squeeze.hpp>
+#include <migraphx/op/sub.hpp>
+#include <migraphx/op/tanh.hpp>
+#include <migraphx/op/tan.hpp>
+#include <migraphx/op/transpose.hpp>
+#include <migraphx/op/unary.hpp>
+#include <migraphx/op/unsqueeze.hpp>
 
 #endif

src/include/migraphx/ranges.hpp

@@ -71,6 +71,30 @@ bool all_of(const std::initializer_list<T>& c, const Predicate& p)
     return std::all_of(c.begin(), c.end(), p);
 }
 
+template <class C, class Predicate>
+bool any_of(const C& c, const Predicate& p)
+{
+    return std::any_of(c.begin(), c.end(), p);
+}
+
+template <class T, class Predicate>
+bool any_of(const std::initializer_list<T>& c, const Predicate& p)
+{
+    return std::any_of(c.begin(), c.end(), p);
+}
+
+template <class C, class Predicate>
+bool none_of(const C& c, const Predicate& p)
+{
+    return std::none_of(c.begin(), c.end(), p);
+}
+
+template <class T, class Predicate>
+bool none_of(const std::initializer_list<T>& c, const Predicate& p)
+{
+    return std::none_of(c.begin(), c.end(), p);
+}
+
 template <class Range, class Iterator>
 void copy(Range&& r, Iterator it)
 {

src/include/migraphx/rewrite_rnn.hpp

@@ -4,7 +4,7 @@
 #include <string>
 #include <vector>
 #include <migraphx/instruction_ref.hpp>
-#include <migraphx/operators.hpp>
+#include <migraphx/operation.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {

src/include/migraphx/schedule.hpp

@@ -17,6 +17,7 @@ struct program;
 struct schedule
 {
     schedule_model model{};
+    bool enable = true;
     std::string name() const { return "schedule"; }
     void apply(program& p) const;
 };

src/onnx/onnx.cpp

@@ -36,7 +36,6 @@ struct onnx_parser
 
     onnx_parser()
     {
-        add_generic_op("MatMul", op::dot{});
         add_generic_op("Relu", op::relu{});
         add_generic_op("Sigmoid", op::sigmoid{});
         add_generic_op("Abs", op::abs{});
@@ -77,6 +76,7 @@ struct onnx_parser
         add_mem_op("Reshape", &onnx_parser::parse_reshape);
         add_mem_op("Flatten", &onnx_parser::parse_flatten);
         add_mem_op("Gemm", &onnx_parser::parse_gemm);
+        add_mem_op("MatMul", &onnx_parser::parse_matmul);
         add_mem_op("BatchNormalization", &onnx_parser::parse_batchnorm);
         add_mem_op("Softmax", &onnx_parser::parse_softmax);
         add_mem_op("LogSoftmax", &onnx_parser::parse_logsoftmax);
@@ -154,42 +154,48 @@ struct onnx_parser
         });
     }
 
+    std::vector<std::size_t> compute_broadcasted_lens(std::vector<std::size_t> s0,
+                                                      std::vector<std::size_t> s1)
+    {
+        // Example:
+        // s0 = (3,2,4,5) and s1 = (2,1,1)
+        //
+        // In this case we need to broadcast (:,1,1) portion of
+        // s1 plus broadcast the 1st dimension of s1
+        // giving output_lens = (3,2,4,5)
+        //
+        // Another example:
+        // s0 = (3,2,1,5) and s1 = (2,7,5)
+        // In this case we need to broadcast the (:,:,1:,:) axis
+        // of s0 plus the 1st dimension of s1 giving
+        // output_lens = (3,2,7,5)
+        if(s0.size() > s1.size())
+        {
+            s0.swap(s1);
+        }
+
+        std::vector<std::size_t> out_lens(s1);
+        auto offset = s1.size() - s0.size();
+        std::transform(s0.begin(),
+                       s0.end(),
+                       s1.begin() + offset,
+                       out_lens.begin() + offset,
+                       [](auto a, auto b) { return std::max(a, b); });
+
+        return out_lens;
+    }
+
     template <class T>
     instruction_ref add_broadcastable_binary_op(instruction_ref arg0, instruction_ref arg1, T x)
     {
         if(arg0->get_shape().lens() != arg1->get_shape().lens())
         {
-            // Example:
-            // s0 = (3,2,4,5) and s1 = (2,1,1)
-            //
-            // In this case we need to broadcast (:,1,1) portion of
-            // s1 plus broadcast the 1st dimension of s1
-            // giving output_lens = (3,2,4,5)
-            //
-            // Another example:
-            // s0 = (3,2,1,5) and s1 = (2,7,5)
-            // In this case we need to broadcast the (:,:,1:,:) axis
-            // of s0 plus the 1st dimension of s1 giving
-            // output_lens = (3,2,7,5)
-            //
             // Get lengths for both arguments
-            const std::vector<std::size_t>* s0 = &arg0->get_shape().lens();
-            const std::vector<std::size_t>* s1 = &arg1->get_shape().lens();
-
-            // Make sure s0 is the smaller size
-            if(s0->size() > s1->size())
-                std::swap(s0, s1);
-
-            std::vector<std::size_t> output_lens(*s1);
-            auto offset = s1->size() - s0->size();
-            std::transform(s0->begin(),
-                           s0->end(),
-                           s1->begin() + offset,
-                           output_lens.begin() + offset,
-                           [](auto a, auto b) { return std::max(a, b); });
-
-            auto l0 = prog.add_instruction(op::multibroadcast{output_lens}, arg0);
-            auto l1 = prog.add_instruction(op::multibroadcast{output_lens}, arg1);
+            auto s0       = arg0->get_shape().lens();
+            auto s1       = arg1->get_shape().lens();
+            auto out_lens = compute_broadcasted_lens(s0, s1);
+            auto l0       = prog.add_instruction(op::multibroadcast{out_lens}, arg0);
+            auto l1       = prog.add_instruction(op::multibroadcast{out_lens}, arg1);
             return prog.add_instruction(x, l0, l1);
         }
         else
@@ -500,19 +506,80 @@ struct onnx_parser
                 auto out_lens   = l1->get_shape().lens();
                 out_lens.back() = l2->get_shape().lens().back();
                 auto l3         = args[2];
-                if(!std::equal(
-                       out_lens.begin(), out_lens.end(), args[2]->get_shape().lens().begin()) &&
-                   out_lens.size() > 2)
+                auto l3_lens    = l3->get_shape().lens();
+                if(!std::equal(out_lens.begin(), out_lens.end(), l3_lens.begin(), l3_lens.end()))
                 {
                     l3 = prog.add_instruction(op::multibroadcast{out_lens}, args[2]);
                 }
-
                 return prog.add_instruction(op::dot{alpha, beta}, l1, l2, l3);
             }
         }
         return prog.add_instruction(op::dot{alpha}, l1, l2);
     }
 
+    instruction_ref
+    parse_matmul(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
+    {
+        auto l0      = args[0];
+        auto l1      = args[1];
+        auto l0_lens = l0->get_shape().lens();
+        auto l1_lens = l1->get_shape().lens();
+
+        // args[0] is a vector, prepend 1 to the shape
+        bool is_a_prepended = false;
+        if(l0_lens.size() == 1)
+        {
+            is_a_prepended = true;
+            l0_lens.insert(l0_lens.begin(), 1);
+            l0 = prog.add_instruction(op::unsqueeze{{0}}, args[0]);
+        }
+
+        bool is_b_appended = false;
+        if(l1_lens.size() == 1)
+        {
+            is_b_appended = true;
+            l1_lens.push_back(1);
+            l1 = prog.add_instruction(op::unsqueeze{{1}}, args[1]);
+        }
+
+        instruction_ref bl0 = l0;
+        instruction_ref bl1 = l1;
+        if(!std::equal(l0_lens.rbegin() + 2, l0_lens.rend(), l1_lens.rbegin() + 2, l1_lens.rend()))
+        {
+            auto l0_it = l0_lens.begin() + l0_lens.size() - 2;
+            std::vector<std::size_t> l0_broadcasted_lens(l0_lens.begin(), l0_it);
+            auto l1_it = l1_lens.begin() + l1_lens.size() - 2;
+            std::vector<std::size_t> l1_broadcasted_lens(l1_lens.begin(), l1_it);
+            auto output_lens = compute_broadcasted_lens(l0_broadcasted_lens, l1_broadcasted_lens);
+            l0_broadcasted_lens = output_lens;
+            l0_broadcasted_lens.insert(l0_broadcasted_lens.end(), l0_it, l0_lens.end());
+            l1_broadcasted_lens = output_lens;
+            l1_broadcasted_lens.insert(l1_broadcasted_lens.end(), l1_it, l1_lens.end());
+            if(l0_lens != l0_broadcasted_lens)
+            {
+                bl0 = prog.add_instruction(op::multibroadcast{l0_broadcasted_lens}, l0);
+            }
+            if(l1_lens != l1_broadcasted_lens)
+            {
+                bl1 = prog.add_instruction(op::multibroadcast{l1_broadcasted_lens}, l1);
+            }
+        }
+
+        auto dot_res     = prog.add_instruction(op::dot{1.0f, 0.0f}, bl0, bl1);
+        int64_t num_axis = static_cast<int64_t>(dot_res->get_shape().lens().size());
+        if(is_a_prepended)
+        {
+            dot_res = prog.add_instruction(op::squeeze{{num_axis - 2}}, dot_res);
+            --num_axis;
+        }
+        if(is_b_appended)
+        {
+            dot_res = prog.add_instruction(op::squeeze{{num_axis - 1}}, dot_res);
+        }
+
+        return dot_res;
+    }
+
     instruction_ref
     parse_batchnorm(const std::string&, attribute_map attributes, std::vector<instruction_ref> args)
     {

src/opt/memory_coloring_impl.cpp

+#include <migraphx/op/load.hpp>
 #include "memory_coloring_impl.hpp"
 
 namespace migraphx {

src/opt/memory_coloring_impl.hpp

@@ -3,7 +3,6 @@
 #include <migraphx/program.hpp>
 #include <migraphx/stringutils.hpp>
 #include <migraphx/instruction.hpp>
-#include <migraphx/operators.hpp>
 #include <migraphx/iterator_for.hpp>
 #include <migraphx/pass_config.hpp>
 #include <migraphx/config.hpp>

src/program.cpp

 #include <migraphx/program.hpp>
 #include <migraphx/stringutils.hpp>
 #include <migraphx/instruction.hpp>
-#include <migraphx/operators.hpp>
+#include <migraphx/op/identity.hpp>
 #include <migraphx/target.hpp>
 #include <migraphx/env.hpp>
 #include <migraphx/ranges.hpp>

src/schedule.cpp

 #include <migraphx/schedule.hpp>
 #include <migraphx/program.hpp>
 #include <migraphx/instruction.hpp>
-#include <migraphx/operators.hpp>
+#include <migraphx/op/identity.hpp>
 #include <migraphx/iterator_for.hpp>
 #include <migraphx/dfor.hpp>
 #include <migraphx/functional.hpp>
@@ -341,6 +341,8 @@ struct stream_info
 
 void schedule::apply(program& p) const
 {
+    if(not enable)
+        return;
     stream_info si;
     auto last = std::prev(p.end());
     si.accumulate_weights(last, model);

src/simplify_algebra.cpp

 #include <migraphx/simplify_algebra.hpp>
 #include <migraphx/program.hpp>
-#include <migraphx/operators.hpp>
+#include <migraphx/op/add.hpp>
 #include <migraphx/matcher.hpp>
 #include <migraphx/literal.hpp>