Merge branch 'develop' into resize_op

test/ref/unique.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * 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 <migraphx/instruction.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/onnx.hpp>
+#include <migraphx/register_target.hpp>
+#include <migraphx/verify.hpp>
+#include <optional>
+#include <test.hpp>
+
+namespace {
+
+migraphx::program
+create_program(const migraphx::shape& data_shape, int64_t sorted, std::optional<int64_t> axis)
+{
+    migraphx::program p;
+    auto* mm  = p.get_main_module();
+    auto data = mm->add_parameter("X", data_shape);
+    auto op   = axis ? migraphx::make_op("unique", {{"axis", *axis}, {"sorted", sorted}})
+                     : migraphx::make_op("unique", {{"sorted", sorted}});
+
+    auto r = mm->add_instruction(op, data);
+
+    auto r0 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), r);
+    auto r1 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), r);
+    auto r2 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), r);
+    auto r3 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 3}}), r);
+    mm->add_return({r0, r1, r2, r3});
+    return p;
+};
+
+template <typename T>
+auto run_program(T& data,
+                 const migraphx::shape& data_shape,
+                 int sorted,
+                 std::optional<int64_t> axis = std::nullopt)
+{
+    auto p = create_program(data_shape, sorted, axis);
+    p.compile(migraphx::make_target("ref"));
+    migraphx::parameter_map pp;
+    pp["X"]   = migraphx::argument(data_shape, data.data());
+    auto rets = p.eval(pp);
+    std::vector<typename std::remove_reference_t<decltype(data)>::value_type> y;
+    rets[0].visit([&](auto v) { y.assign(v.begin(), v.end()); });
+    std::vector<int64_t> y_idx;
+    rets[1].visit([&](auto v) { y_idx.assign(v.begin(), v.end()); });
+    std::vector<int64_t> x_rev_idx;
+    rets[2].visit([&](auto v) { x_rev_idx.assign(v.begin(), v.end()); });
+    std::vector<int64_t> y_ct;
+    rets[3].visit([&](auto v) { y_ct.assign(v.begin(), v.end()); });
+
+    return std::make_tuple(y, y_idx, x_rev_idx, y_ct);
+}
+} // namespace
+
+// sorted. single entry
+TEST_CASE(unique_sorted_single_entry_test)
+{
+    std::vector<int> data    = {2};
+    int64_t axis             = 0;
+    int64_t sorted           = 1;
+    std::vector<size_t> lens = {1};
+    migraphx::shape data_shape{migraphx::shape::int32_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<int> gold_val = {2};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1};
+    EXPECT(ct == gold_ct);
+}
+
+// unsorted. single entry
+TEST_CASE(unique_unsorted_single_entry_test)
+{
+    std::vector<float> data  = {3.33};
+    int64_t axis             = -1;
+    int64_t sorted           = 0;
+    std::vector<size_t> lens = {1};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {3.33};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1};
+    EXPECT(ct == gold_ct);
+}
+
+// case 2  sorted. all unique input..
+TEST_CASE(unique_sorted_all_unique_test)
+{
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9};
+    int64_t axis             = 0;
+    int64_t sorted           = 1;
+    std::vector<size_t> lens = {5};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {1.9, 2.1, 2.3, 2.4, 2.5};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {4, 0, 1, 2, 3};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {1, 2, 3, 4, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1, 1, 1, 1, 1};
+    EXPECT(ct == gold_ct);
+}
+
+// case 3  unsorted. all unique input
+TEST_CASE(unique_unsorted_all_unique_test)
+{
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9};
+    int64_t axis             = 0;
+    int64_t sorted           = 0;
+    std::vector<size_t> lens = {5};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {2.1, 2.3, 2.4, 2.5, 1.9};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 1, 2, 3, 4};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 1, 2, 3, 4};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1, 1, 1, 1, 1};
+    EXPECT(ct == gold_ct);
+}
+
+// case 4  sorted (with dup entries)
+TEST_CASE(unique_sorted_dupes_test)
+{
+    std::vector<double> data = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.5};
+    int64_t axis             = 0;
+    int64_t sorted           = 1;
+    std::vector<size_t> lens = {8};
+    migraphx::shape data_shape{migraphx::shape::double_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<double> gold_val = {1.9, 2.1, 2.3, 2.4, 2.5};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_ct = {1, 1, 2, 1, 3};
+    EXPECT(ct == gold_ct);
+}
+
+// case 5  unsorted (with dup entries)
+TEST_CASE(unique_unsorted_dupes_test)
+{
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.1};
+    int64_t axis             = -1;
+    int64_t sorted           = 0;
+    std::vector<size_t> lens = {8};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {2.1, 2.3, 2.4, 2.5, 1.9};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 1, 2, 3, 4};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 1, 2, 3, 4, 3, 1, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 2, 1, 2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+TEST_CASE(unique_3D_no_axis_test)
+{
+    // sorted 3D (with dup entries). no axis
+    int sorted                  = 1;
+    std::vector<double> data_3d = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.5};
+    std::vector<size_t> lens    = {2, 2, 2}; // 3D data. type double
+    migraphx::shape data_shape{migraphx::shape::double_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data_3d, data_shape, sorted);
+
+    std::vector<double> gold_val = {1.9, 2.1, 2.3, 2.4, 2.5};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_ct = {1, 1, 2, 1, 3};
+    EXPECT(ct == gold_ct);
+}
+
+TEST_CASE(unique_3D_no_axis_unsorted_test)
+//  unsorted 3D (with dup entries). no axis
+{
+    int sorted               = 0;
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.1};
+    std::vector<size_t> lens = {2, 1, 4}; // 3D data. type float
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted);
+
+    std::vector<float> gold_val = {2.1, 2.3, 2.4, 2.5, 1.9};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 1, 2, 3, 4};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 1, 2, 3, 4, 3, 1, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 2, 1, 2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+//  unique integer sub-tensors: sorted (with dup entries)
+TEST_CASE(unique_subtensors_sorted_test)
+{
+    /*
+      input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+      attribute_sorted = 1
+      attribute_axis = 0
+      output_Y = [[1, 0, 0], [2, 3, 4]]
+      output_indices = [0, 2]
+      output_inverse_indices = [0, 0, 1]
+      output_counts = [2, 1]
+    */
+
+    int axis                  = 0;
+    int sorted                = 1;
+    std::vector<int32_t> data = {1, 0, 0, 1, 0, 0, 2, 3, 4};
+    std::vector<size_t> lens  = {3, 3};
+    migraphx::shape data_shape{migraphx::shape::int32_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<int32_t> gold_val = {1, 0, 0, 2, 3, 4};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 2};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 0, 1};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+//  unique integer sub-tensors: un-sorted (with dup entries)
+TEST_CASE(unique_subtensors_neg_axis_test)
+{
+    /*
+      input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+      attribute_sorted = 0
+      attribute_axis = 0
+      output_Y = [[1, 0, 0], [2, 3, 4]]
+      output_indices = [0, 2]
+      output_inverse_indices = [0, 0, 1]
+      output_counts = [2, 1]
+    */
+
+    int axis                  = -2; // == 0
+    int sorted                = 0;
+    std::vector<int32_t> data = {1, 0, 0, 1, 0, 0, 2, 3, 4};
+    std::vector<size_t> lens  = {3, 3};
+    migraphx::shape data_shape{migraphx::shape::int32_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<int32_t> gold_val = {1, 0, 0, 2, 3, 4};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 2};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 0, 1};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+//  unique float sub-tensors: sorted (with dup entries)  axis = 0
+TEST_CASE(unique_subtensors_zero_axis_test)
+{
+    /*
+      input_x = [[[1., 1.], [0., 1.], [2., 1.], [0., 1.]],
+      [[1., 1.], [0., 1.], [2., 1.], [0., 1.]]]
+      attribute_sorted = 1
+      attribute_axis = 0
+    */
+
+    int axis                 = 0;
+    int sorted               = 1;
+    std::vector<float> data  = {1., 1., 0., 1., 2., 1., 0., 1., 1., 1., 0., 1., 2., 1., 0., 1.};
+    std::vector<size_t> lens = {2, 4, 2};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {1., 1., 0., 1., 2., 1., 0., 1.};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2};
+    EXPECT(ct == gold_ct);
+}

test/rewrite_pooling_test.cpp

@@ -53,7 +53,8 @@ TEST_CASE(rewrite_pooling_test)
                                                          {{"mode", mode},
                                                           {"padding", {0, 0, 0}},
                                                           {"stride", {1, 1, 1}},
-                                                          {"lengths", {3, 4, 5}}}),
+                                                          {"lengths", {3, 4, 5}},
+                                                          {"dilations", {1, 1, 1}}}),
                                      input);
         m.add_return({ret});
         return m;
@@ -80,6 +81,483 @@ TEST_CASE(rewrite_pooling_test)
                  migraphx::make_op("reduce_max", {{"axes", {2, 3, 4}}}));
 }
 
+TEST_CASE(rewrite_pooling_dialtions_test)
+{
+    migraphx::shape s{migraphx::shape::float_type, {1, 1, 5, 5}};
+    auto pooling_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        auto ret   = m.add_instruction(migraphx::make_op("pooling",
+                                                         {{"mode", mode},
+                                                          {"padding", {0, 0}},
+                                                          {"stride", {1, 1}},
+                                                          {"lengths", {2, 2}},
+                                                          {"dilations", {2, 2}}}),
+                                     input);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto opt_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        std::vector<int> indices{0, 2, 1, 3, 2, 4};
+        migraphx::shape s_indices{migraphx::shape::int32_type, {indices.size()}};
+        auto i1  = m.add_literal(migraphx::literal{s_indices, indices});
+        auto g1  = m.add_instruction(migraphx::make_op("gather", {{"axis", 2}}), input, i1);
+        auto i2  = m.add_literal(migraphx::literal{s_indices, indices});
+        auto g2  = m.add_instruction(migraphx::make_op("gather", {{"axis", 3}}), g1, i2);
+        auto ret = m.add_instruction(migraphx::make_op("pooling",
+                                                       {{"mode", mode},
+                                                        {"padding", {0, 0}},
+                                                        {"stride", {2, 2}},
+                                                        {"lengths", {2, 2}},
+                                                        {"dilations", {1, 1}}}),
+                                     g2);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto test_rewrite = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m1 = pooling_program(mode);
+        migraphx::module m2 = opt_program(mode);
+        opt_pooling(m1);
+        EXPECT(m1 == m2);
+    };
+
+    test_rewrite(migraphx::op::pooling_mode::average);
+    test_rewrite(migraphx::op::pooling_mode::max);
+}
+
+TEST_CASE(rewrite_pooling_dialtions_test2)
+{
+    migraphx::shape s{migraphx::shape::float_type, {1, 1, 5, 5, 5}};
+    auto pooling_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        auto ret   = m.add_instruction(migraphx::make_op("pooling",
+                                                         {{"mode", mode},
+                                                          {"padding", {0, 0, 0}},
+                                                          {"stride", {1, 1, 1}},
+                                                          {"lengths", {2, 2, 2}},
+                                                          {"dilations", {2, 2, 2}}}),
+                                     input);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto opt_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        std::vector<int> indices{0, 2, 1, 3, 2, 4};
+        migraphx::shape s_indices{migraphx::shape::int32_type, {indices.size()}};
+        auto i1  = m.add_literal(migraphx::literal{s_indices, indices});
+        auto g1  = m.add_instruction(migraphx::make_op("gather", {{"axis", 2}}), input, i1);
+        auto i2  = m.add_literal(migraphx::literal{s_indices, indices});
+        auto g2  = m.add_instruction(migraphx::make_op("gather", {{"axis", 3}}), g1, i2);
+        auto i3  = m.add_literal(migraphx::literal{s_indices, indices});
+        auto g3  = m.add_instruction(migraphx::make_op("gather", {{"axis", 4}}), g2, i3);
+        auto ret = m.add_instruction(migraphx::make_op("pooling",
+                                                       {{"mode", mode},
+                                                        {"padding", {0, 0, 0}},
+                                                        {"stride", {2, 2, 2}},
+                                                        {"lengths", {2, 2, 2}},
+                                                        {"dilations", {1, 1, 1}}}),
+                                     g3);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto test_rewrite = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m1 = pooling_program(mode);
+        migraphx::module m2 = opt_program(mode);
+        opt_pooling(m1);
+        EXPECT(m1 == m2);
+    };
+
+    test_rewrite(migraphx::op::pooling_mode::average);
+    test_rewrite(migraphx::op::pooling_mode::max);
+}
+
+TEST_CASE(rewrite_pooling_dialtions_test3)
+{
+    migraphx::shape s{migraphx::shape::float_type, {2, 2, 5}};
+    auto pooling_program = [&]() {
+        migraphx::module m;
+
+        auto input = m.add_parameter("x", s);
+        auto ret =
+            m.add_instruction(migraphx::make_op("pooling",
+                                                {{"mode", migraphx::op::pooling_mode::average},
+                                                 {"padding", {1}},
+                                                 {"stride", {1}},
+                                                 {"lengths", {3}},
+                                                 {"dilations", {2}}}),
+                              input);
+        m.add_return({ret});
+        return m;
+    };
+
+    migraphx::module m1 = pooling_program();
+    migraphx::module m2 = m1;
+
+    opt_pooling(m1);
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(rewrite_pooling_dialtions_test4)
+{
+    migraphx::shape s{migraphx::shape::float_type, {1, 1, 5, 5}};
+    auto pooling_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        auto ret   = m.add_instruction(migraphx::make_op("pooling",
+                                                         {{"mode", mode},
+                                                          {"padding", {1, 0}},
+                                                          {"stride", {1, 3}},
+                                                          {"lengths", {3, 1}},
+                                                          {"dilations", {1, 2}}}),
+                                     input);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto opt_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        std::vector<int> col_indices{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+        migraphx::shape s_col_indices{migraphx::shape::int32_type, {col_indices.size()}};
+        std::vector<int> row_indices{0, 3};
+        migraphx::shape s_row_indices{migraphx::shape::int32_type, {row_indices.size()}};
+        auto p =
+            m.add_instruction(migraphx::make_op("pad",
+                                                {{"pads", {0, 0, 1, 0, 0, 0, 1, 0}},
+                                                 {"value", std::numeric_limits<float>::lowest()}}),
+                              input);
+        auto i1  = m.add_literal(migraphx::literal{s_col_indices, col_indices});
+        auto g1  = m.add_instruction(migraphx::make_op("gather", {{"axis", 2}}), p, i1);
+        auto i2  = m.add_literal(migraphx::literal{s_row_indices, row_indices});
+        auto g2  = m.add_instruction(migraphx::make_op("gather", {{"axis", 3}}), g1, i2);
+        auto ret = m.add_instruction(migraphx::make_op("pooling",
+                                                       {{"mode", mode},
+                                                        {"padding", {0, 0}},
+                                                        {"stride", {3, 1}},
+                                                        {"lengths", {3, 1}},
+                                                        {"dilations", {1, 1}}}),
+                                     g2);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto test_rewrite = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m1 = pooling_program(mode);
+        migraphx::module m2 = opt_program(mode);
+        opt_pooling(m1);
+        EXPECT(m1 == m2);
+    };
+
+    // Average won't work because of padding
+    test_rewrite(migraphx::op::pooling_mode::max);
+}
+
+TEST_CASE(rewrite_pooling_dialtions_test5)
+{
+    migraphx::shape s{migraphx::shape::float_type, {1, 1, 5, 5}};
+    auto pooling_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        auto ret   = m.add_instruction(migraphx::make_op("pooling",
+                                                         {{"mode", mode},
+                                                          {"padding", {0, 0}},
+                                                          {"stride", {2, 3}},
+                                                          {"lengths", {2, 1}},
+                                                          {"dilations", {1, 2}}}),
+                                     input);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto opt_program = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m;
+        auto input = m.add_parameter("x", s);
+        std::vector<int> col_indices{0, 1, 2, 3};
+        migraphx::shape s_col_indices{migraphx::shape::int32_type, {col_indices.size()}};
+        std::vector<int> row_indices{0, 3};
+        migraphx::shape s_row_indices{migraphx::shape::int32_type, {row_indices.size()}};
+        auto i1  = m.add_literal(migraphx::literal{s_col_indices, col_indices});
+        auto g1  = m.add_instruction(migraphx::make_op("gather", {{"axis", 2}}), input, i1);
+        auto i2  = m.add_literal(migraphx::literal{s_row_indices, row_indices});
+        auto g2  = m.add_instruction(migraphx::make_op("gather", {{"axis", 3}}), g1, i2);
+        auto ret = m.add_instruction(migraphx::make_op("pooling",
+                                                       {{"mode", mode},
+                                                        {"padding", {0, 0}},
+                                                        {"stride", {2, 1}},
+                                                        {"lengths", {2, 1}},
+                                                        {"dilations", {1, 1}}}),
+                                     g2);
+        m.add_return({ret});
+        return m;
+    };
+
+    auto test_rewrite = [&](const migraphx::op::pooling_mode mode) {
+        migraphx::module m1 = pooling_program(mode);
+        migraphx::module m2 = opt_program(mode);
+        opt_pooling(m1);
+        EXPECT(m1 == m2);
+    };
+
+    test_rewrite(migraphx::op::pooling_mode::average);
+    test_rewrite(migraphx::op::pooling_mode::max);
+}
+
+TEST_CASE(rewrite_avgpool_rank3_dil_test)
+{
+    // 1D case 1, input is 3D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    op.lengths   = {2};
+    op.padding   = {0};
+    op.stride    = {1};
+    op.dilations = {2};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.35, 0.15, 0.85, 0.3, 0.1, 0.65};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(rewrite_avgpool_rank3_dil_test2)
+{
+    // 1D case 1, input is 3D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    op.lengths   = {2};
+    op.padding   = {0};
+    op.stride    = {1};
+    op.dilations = {3};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.2, 0.45, 0.35};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(rewrite_avgpool_rank4_test)
+{
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    op.lengths   = {2, 1};
+    op.padding   = {0, 0};
+    op.stride    = {2, 3};
+    op.dilations = {1, 2};
+
+    std::vector<float> data(25);
+    std::iota(data.begin(), data.end(), 1);
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{3.5, 6.5, 13.5, 16.5};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(rewrite_maxpool_rank3_test)
+{
+    // 1D case 1, input is 3D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {2};
+    op.padding   = {0};
+    op.stride    = {1};
+    op.dilations = {2};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.4, 0.2, 0.9, 0.5, 0.1, 0.7};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(rewrite_maxpool_rank3_test2)
+{
+    // 1D case 1, input is 3D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {2};
+    op.padding   = {1};
+    op.stride    = {1};
+    op.dilations = {3};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.4, 0.3, 0.2, 0.9, 0.8, 0.5, 0.1, 0.6, 0.7};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(rewrite_maxpool_rank3_test3)
+{
+    // 1D case 1, input is 3D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {3};
+    op.padding   = {2};
+    op.stride    = {2};
+    op.dilations = {3};
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.2, 0.5, 0.7};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(rewrite_maxpool_rank4_test)
+{
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {3, 1};
+    op.padding   = {1, 0};
+    op.stride    = {1, 3};
+    op.dilations = {1, 2};
+
+    std::vector<float> data(25);
+    std::iota(data.begin(), data.end(), 1);
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{6, 9, 11, 14, 16, 19, 21, 24, 21, 24};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(maxpool_rank5_test)
+{
+    // 3D, input is 5D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {2, 2, 2};
+    op.padding   = {0, 0, 0};
+    op.stride    = {1, 1, 1};
+    op.dilations = {2, 2, 2};
+
+    std::vector<float> data{
+        -2.8029, 0.5861,  0.7015,  0.1297,  -1.44,   -1.9472, 0.7812,  2.408,   -0.3145, 0.3405,
+        -0.9146, 0.0624,  1.5064,  -0.8345, 1.7977,  1.8949,  1.0073,  -0.2102, -0.042,  -0.7146,
+        0.6227,  -0.5263, -2.2598, 0.1713,  0.449,   0.5303,  -0.8622, -0.5691, 0.907,   -0.0569,
+        -1.5348, -0.4109, -0.1461, -0.5445, 0.4266,  0.2282,  1.3655,  -2.1519, 0.6068,  -0.2001,
+        -0.4702, 0.3864,  1.7083,  0.9096,  0.4286,  -1.8866, 0.7034,  0.0293,  1.4587,  0.7672,
+        -2.8614, 0.8124,  -0.053,  1.0449,  0.845,   -0.0131, 0.1139,  -0.859,  -1.2681, -0.6337,
+        -0.4644, 0.1938,  0.2889,  0.9035,  0.7118,  -0.5767, 0.4577,  -0.0549, 0.2237,  0.5756,
+        0.0677,  -0.0223, -0.329,  0.2364,  2.7666,  -0.7417, -1.3196, -0.2655, 0.1698,  -0.1777,
+        -0.9427, 2.6859,  -0.7501, 0.5175,  1.0029,  -2.6436, -0.4388, -1.2348, -0.1539, -0.6229,
+        -0.4136, 0.5085,  0.4136,  -0.6439, -1.1953, -0.406,  -0.0195, 0.1869,  -0.8664, 1.1364,
+        0.5041,  0.0647,  0.1941,  -1.0819, -0.4629, -0.5107, 0.3612,  -0.3583};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.7812, 1.0449, 2.7666, 2.6859};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(maxpool_rank5_test2)
+{
+    // 3D, input is 5D
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {2, 2, 2};
+    op.padding   = {2, 2, 2};
+    op.stride    = {2, 2, 2};
+    op.dilations = {3, 3, 3};
+
+    std::vector<float> data{
+        -2.8029, 0.5861,  0.7015,  0.1297,  -1.44,   -1.9472, 0.7812,  2.408,   -0.3145, 0.3405,
+        -0.9146, 0.0624,  1.5064,  -0.8345, 1.7977,  1.8949,  1.0073,  -0.2102, -0.042,  -0.7146,
+        0.6227,  -0.5263, -2.2598, 0.1713,  0.449,   0.5303,  -0.8622, -0.5691, 0.907,   -0.0569,
+        -1.5348, -0.4109, -0.1461, -0.5445, 0.4266,  0.2282,  1.3655,  -2.1519, 0.6068,  -0.2001,
+        -0.4702, 0.3864,  1.7083,  0.9096,  0.4286,  -1.8866, 0.7034,  0.0293,  1.4587,  0.7672,
+        -2.8614, 0.8124,  -0.053,  1.0449,  0.845,   -0.0131, 0.1139,  -0.859,  -1.2681, -0.6337,
+        -0.4644, 0.1938,  0.2889,  0.9035,  0.7118,  -0.5767, 0.4577,  -0.0549, 0.2237,  0.5756,
+        0.0677,  -0.0223, -0.329,  0.2364,  2.7666,  -0.7417, -1.3196, -0.2655, 0.1698,  -0.1777,
+        -0.9427, 2.6859,  -0.7501, 0.5175,  1.0029,  -2.6436, -0.4388, -1.2348, -0.1539, -0.6229,
+        -0.4136, 0.5085,  0.4136,  -0.6439, -1.1953, -0.406,  -0.0195, 0.1869,  -0.8664, 1.1364,
+        0.5041,  0.0647,  0.1941,  -1.0819, -0.4629, -0.5107, 0.3612,  -0.3583};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    opt_pooling(*mm);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{-0.8345, 1.5064,  -0.9146, 0.3405,  -1.44,   0.1297,  0.5861,  -2.8029,
+                            -0.4702, -0.2001, -2.1519, 1.3655,  -0.4109, -1.5348, 0.907,   -0.5691,
+                            -0.0549, 0.4577,  0.7118,  0.9035,  -1.2681, -0.859,  -0.0131, 0.845,
+                            -1.1953, -0.6439, 0.5085,  -0.4136, -2.6436, 1.0029,  -0.7501, 2.6859};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
 TEST_CASE(rewrite_avepooling_na1_test)
 {
     migraphx::shape s{migraphx::shape::float_type, {2, 2, 3, 4, 5}};
@@ -92,7 +570,8 @@ TEST_CASE(rewrite_avepooling_na1_test)
                                                 {{"mode", migraphx::op::pooling_mode::average},
                                                  {"padding", {0, 1, 0}},
                                                  {"stride", {1, 1, 1}},
-                                                 {"lengths", {3, 4, 5}}}),
+                                                 {"lengths", {3, 4, 5}},
+                                                 {"dilations", {1, 1, 1}}}),
                               input);
         m.add_return({ret});
         return m;
@@ -117,7 +596,8 @@ TEST_CASE(rewrite_avepooling_na2_test)
                                                 {{"mode", migraphx::op::pooling_mode::average},
                                                  {"padding", {0, 0, 0}},
                                                  {"stride", {1, 2, 1}},
-                                                 {"lengths", {3, 4, 5}}}),
+                                                 {"lengths", {3, 4, 5}},
+                                                 {"dilations", {1, 1, 1}}}),
                               input);
         m.add_return({ret});
         return m;
@@ -141,7 +621,8 @@ TEST_CASE(rewrite_avepooling_na3_test)
                                                          {{"mode", migraphx::op::pooling_mode::max},
                                                           {"padding", {0, 0, 0}},
                                                           {"stride", {1, 1, 1}},
-                                                          {"lengths", {3, 3, 5}}}),
+                                                          {"lengths", {3, 3, 5}},
+                                                          {"dilations", {1, 1, 1}}}),
                                      input);
         m.add_return({ret});
         return m;
@@ -169,7 +650,8 @@ TEST_CASE(literal_rewrite_pooling_test)
                                                            {{"mode", mode},
                                                             {"padding", {0, 0, 0}},
                                                             {"stride", {1, 1, 1}},
-                                                            {"lengths", {3, 4, 5}}}),
+                                                            {"lengths", {3, 4, 5}},
+                                                            {"dilations", {1, 1, 1}}}),
                                        input);
         mm->add_return({ret});
         return p;

test/simplify_algebra_test.cpp

@@ -1017,6 +1017,40 @@ TEST_CASE(simplify_concat_add_relu_broadcast_same_axis)
     EXPECT(m1 == m2);
 }
 
+TEST_CASE(concat_convert_fusion)
+{
+    auto s = migraphx::shape{migraphx::shape::float_type, {64}};
+    migraphx::module m1;
+    {
+        auto x  = m1.add_parameter("x", s);
+        auto y  = m1.add_parameter("y", s);
+        auto xh = m1.add_instruction(
+            migraphx::make_op("convert",
+                              {{"target_type", migraphx::to_value(migraphx::shape::half_type)}}),
+            x);
+        auto yh = m1.add_instruction(
+            migraphx::make_op("convert",
+                              {{"target_type", migraphx::to_value(migraphx::shape::half_type)}}),
+            y);
+        auto concat = m1.add_instruction(migraphx::make_op("concat", {{"axis", 0}}), xh, yh);
+        m1.add_instruction(pass_op{}, concat);
+    }
+    run_pass(m1);
+
+    migraphx::module m2;
+    {
+        auto x       = m2.add_parameter("x", s);
+        auto y       = m2.add_parameter("y", s);
+        auto concat  = m2.add_instruction(migraphx::make_op("concat", {{"axis", 0}}), x, y);
+        auto concath = m2.add_instruction(
+            migraphx::make_op("convert",
+                              {{"target_type", migraphx::to_value(migraphx::shape::half_type)}}),
+            concat);
+        m2.add_instruction(pass_op{}, concath);
+    }
+    EXPECT(m1 == m2);
+}
+
 TEST_CASE(simplify_div_const)
 {
     migraphx::module m1;

test/simplify_dyn_ops_test.cpp

@@ -155,29 +155,187 @@ TEST_CASE(after_split_dyn_broadcast_match)
     EXPECT(p0 == p1);
 }
 
-TEST_CASE(const_slice_3input)
+TEST_CASE(const_slice_2input_ends_axes)
 {
     migraphx::module m0;
     {
         migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
         auto input = m0.add_parameter("data", s);
+        migraphx::shape s1{migraphx::shape::int32_type, {1}};
+        auto input_starts = m0.add_literal(migraphx::literal{s1, {0}});
         auto slice_ins    = m0.add_instruction(
+            migraphx::make_op("slice", {{"ends", {3}}, {"axes", {0}}}), input, input_starts);
+        m0.add_return({slice_ins});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input     = m1.add_parameter("data", s);
+        auto slice_ins = m1.add_instruction(
             migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
+        m1.add_return({slice_ins});
+    }
+
+    EXPECT(m0 == m1);
+}
+
+TEST_CASE(const_slice_2input_starts_axes)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input = m0.add_parameter("data", s);
+        migraphx::shape s1{migraphx::shape::int32_type, {1}};
+        auto input_ends = m0.add_literal(migraphx::literal{s1, {3}});
+        auto slice_ins  = m0.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"axes", {0}}}), input, input_ends);
         m0.add_return({slice_ins});
     }
+    run_pass(m0);
 
     migraphx::module m1;
     {
         migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
         auto input     = m1.add_parameter("data", s);
+        auto slice_ins = m1.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
+        m1.add_return({slice_ins});
+    }
+
+    EXPECT(m0 == m1);
+}
+
+TEST_CASE(const_slice_2input_starts_ends)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input = m0.add_parameter("data", s);
         migraphx::shape s1{migraphx::shape::int32_type, {1}};
-        auto input_starts = m1.add_literal(migraphx::literal{s1, {0}});
-        auto input_ends   = m1.add_literal(migraphx::literal{s1, {3}});
+        auto input_axes = m0.add_literal(migraphx::literal{s1, {0}});
+        auto slice_ins  = m0.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}}), input, input_axes);
+        m0.add_return({slice_ins});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input     = m1.add_parameter("data", s);
         auto slice_ins = m1.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
+        m1.add_return({slice_ins});
+    }
+
+    EXPECT(m0 == m1);
+}
+
+TEST_CASE(const_slice_3input_axes_only)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input = m0.add_parameter("data", s);
+        migraphx::shape s1{migraphx::shape::int32_type, {1}};
+        auto input_starts = m0.add_literal(migraphx::literal{s1, {0}});
+        auto input_ends   = m0.add_literal(migraphx::literal{s1, {3}});
+        auto slice_ins    = m0.add_instruction(
             migraphx::make_op("slice", {{"axes", {0}}}), input, input_starts, input_ends);
+        m0.add_return({slice_ins});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input     = m1.add_parameter("data", s);
+        auto slice_ins = m1.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
+        m1.add_return({slice_ins});
+    }
+
+    EXPECT(m0 == m1);
+}
+
+TEST_CASE(const_slice_3input_ends_only)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input = m0.add_parameter("data", s);
+        migraphx::shape s1{migraphx::shape::int32_type, {1}};
+        auto input_starts = m0.add_literal(migraphx::literal{s1, {0}});
+        auto input_axes   = m0.add_literal(migraphx::literal{s1, {0}});
+        auto slice_ins    = m0.add_instruction(
+            migraphx::make_op("slice", {{"ends", {3}}}), input, input_starts, input_axes);
+        m0.add_return({slice_ins});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input     = m1.add_parameter("data", s);
+        auto slice_ins = m1.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
+        m1.add_return({slice_ins});
+    }
+
+    EXPECT(m0 == m1);
+}
+
+TEST_CASE(const_slice_3inputs_starts_only)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input = m0.add_parameter("data", s);
+        migraphx::shape s1{migraphx::shape::int32_type, {1}};
+        auto input_ends = m0.add_literal(migraphx::literal{s1, {3}});
+        auto input_axes = m0.add_literal(migraphx::literal{s1, {0}});
+        auto slice_ins  = m0.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}}), input, input_ends, input_axes);
+        m0.add_return({slice_ins});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {6, 4, 4}};
+        auto input     = m1.add_parameter("data", s);
+        auto slice_ins = m1.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
+        m1.add_return({slice_ins});
+    }
+
+    EXPECT(m0 == m1);
+}
+
+TEST_CASE(const_slice_2input_ends_axes_dyn)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {{6, 6}, {2, 4, {2, 4}}, {2, 4, {2, 4}}}};
+        auto input = m0.add_parameter("data", s);
+        migraphx::shape s1{migraphx::shape::int32_type, {1}};
+        auto input_starts = m0.add_literal(migraphx::literal{s1, {0}});
+        auto slice_ins    = m0.add_instruction(
+            migraphx::make_op("slice", {{"ends", {3}}, {"axes", {0}}}), input, input_starts);
+        m0.add_return({slice_ins});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape s{migraphx::shape::float_type, {{6, 6}, {2, 4, {2, 4}}, {2, 4, {2, 4}}}};
+        auto input     = m1.add_parameter("data", s);
+        auto slice_ins = m1.add_instruction(
+            migraphx::make_op("slice", {{"starts", {0}}, {"ends", {3}}, {"axes", {0}}}), input);
         m1.add_return({slice_ins});
     }
-    run_pass(m1);
 
     EXPECT(m0 == m1);
 }
@@ -386,4 +544,31 @@ TEST_CASE(static_dimensions_of_to_constant_alloc_reshape)
     EXPECT(m0 == m1);
 }
 
+TEST_CASE(const_alloc_fill)
+{
+    migraphx::module m0;
+    {
+        migraphx::shape val_shape{migraphx::shape::int64_type, {1}, {0}};
+        std::vector<int64_t> lit_data = {3};
+        auto value_lit                = m0.add_literal(migraphx::literal{val_shape, lit_data});
+        migraphx::shape lit_s{migraphx::shape::int64_type, {3}};
+        auto output_dim_lit = m0.add_literal(migraphx::literal{lit_s, {3, 4, 4}});
+        auto alloc_ins      = m0.add_instruction(
+            migraphx::make_op("allocate", {{"buf_type", migraphx::shape::int64_type}}),
+            output_dim_lit);
+        auto ret = m0.add_instruction(migraphx::make_op("fill"), value_lit, alloc_ins);
+        m0.add_return({ret});
+    }
+    run_pass(m0);
+
+    migraphx::module m1;
+    {
+        migraphx::shape lit_shape{migraphx::shape::int64_type, {3, 4, 4}};
+        std::vector<int64_t> lit_data(3 * 4 * 4, 3);
+        auto ret = m1.add_literal(migraphx::literal{lit_shape, lit_data});
+        m1.add_return({ret});
+    }
+    EXPECT(m0 == m1);
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/simplify_qdq_test.cpp

@@ -788,6 +788,7 @@ TEST_CASE(conv_pooling_dot)
                                                   {"padding", {0, 0, 0, 0}},
                                                   {"stride", {1, 1}},
                                                   {"lengths", {7, 7}},
+                                                  {"dilations", {1, 1}},
                                                   {"ceil_mode", 0}}),
                                a1);
         auto fl  = m1.add_instruction(migraphx::make_op("flatten", {{"axis", 1}}), ap);
@@ -835,6 +836,7 @@ TEST_CASE(conv_pooling_dot)
                                                   {"padding", {0, 0, 0, 0}},
                                                   {"stride", {1, 1}},
                                                   {"lengths", {7, 7}},
+                                                  {"dilations", {1, 1}},
                                                   {"ceil_mode", 0}}),
                                a1);
         auto fl         = m2.add_instruction(migraphx::make_op("flatten", {{"axis", 1}}), ap);
@@ -896,6 +898,7 @@ TEST_CASE(mobilenet_snippet)
                                                   {"padding", {0, 0, 0, 0}},
                                                   {"stride", {1, 1}},
                                                   {"lengths", {7, 7}},
+                                                  {"dilations", {1, 1}},
                                                   {"ceil_mode", 0}}),
                                d6);
         auto q3  = add_quantize_op(mm, "quantizelinear", ap, scale, zero);

test/verify/gemm_softmax_gemm_relu.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * 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 "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct gemm_softmax_gemm_relu : verify_program<gemm_softmax_gemm_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape m1_shape{migraphx::shape::half_type, {1, 12, 256, 256}};
+        migraphx::shape m2_shape{migraphx::shape::half_type, {1, 12, 256, 256}};
+        auto m2_elements = m2_shape.elements();
+        auto a           = mm->add_parameter("1", m1_shape);
+        auto b           = mm->add_parameter("2", m1_shape);
+        auto b1          = mm->add_parameter("3", m1_shape);
+        std::vector<float> eights(m2_elements, 0.125);
+        auto eight = mm->add_literal(migraphx::literal{m2_shape, eights});
+        std::vector<float> zeros(m2_elements, 0);
+        auto zero = mm->add_literal(migraphx::literal{m2_shape, zeros});
+
+        b = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), b);
+        auto gemm1   = mm->add_instruction(migraphx::make_op("dot"), a, b);
+        auto scale   = mm->add_instruction(migraphx::make_op("mul"), gemm1, eight);
+        auto bias    = mm->add_instruction(migraphx::make_op("add"), scale, zero);
+        auto softmax = mm->add_instruction(migraphx::make_op("softmax", {{"axis", 3}}), bias);
+        auto gemm2   = mm->add_instruction(migraphx::make_op("dot"), softmax, b1);
+        mm->add_instruction(migraphx::make_op("relu"), gemm2);
+        return p;
+    }
+};

test/verify/test_abs.cpp

@@ -27,14 +27,19 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_abs : verify_program<test_abs>
+template <migraphx::shape::type_t DType>
+struct test_abs : verify_program<test_abs<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto x   = mm->add_parameter("x", migraphx::shape{DType, {4, 3, 3, 3}});
         mm->add_instruction(migraphx::make_op("abs"), x);
         return p;
     }
 };
+
+template struct test_abs<migraphx::shape::fp8e4m3fnuz_type>;
+template struct test_abs<migraphx::shape::half_type>;
+template struct test_abs<migraphx::shape::float_type>;

test/verify/test_acos.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_acos : verify_program<test_acos>
+template <migraphx::shape::type_t DType>
+struct test_acos : verify_program<test_acos<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape s{DType, {16}};
         auto x = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("acos"), x);
         return p;
     }
 };
+
+template struct test_acos<migraphx::shape::fp8e4m3fnuz_type>;
+template struct test_acos<migraphx::shape::half_type>;
+template struct test_acos<migraphx::shape::float_type>;

test/verify/test_acosh.cpp

@@ -23,20 +23,23 @@
  */
 
 #include "verify_program.hpp"
+#include <migraphx/literal.hpp>
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_acosh : verify_program<test_acosh>
+template <typename CType>
+struct test_acosh : verify_program<test_acosh<CType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm                      = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape::type_t dtype = migraphx::shape::get_type<CType>();
+        migraphx::shape s{dtype, {16}};
         auto x       = mm->add_parameter("x", s);
-        auto min_val = mm->add_literal(1.1f);
-        auto max_val = mm->add_literal(100.0f);
+        auto min_val = mm->add_literal(migraphx::literal{migraphx::shape{dtype}, {1.1f}});
+        auto max_val = mm->add_literal(migraphx::literal{migraphx::shape{dtype}, {100.0f}});
         min_val =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {16}}}), min_val);
         max_val =
@@ -46,3 +49,7 @@ struct test_acosh : verify_program<test_acosh>
         return p;
     }
 };
+
+template struct test_acosh<float>;
+template struct test_acosh<migraphx::half>;
+template struct test_acosh<migraphx::fp8::fp8e4m3fnuz>;

test/verify/test_add.cpp

@@ -27,16 +27,21 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_add : verify_program<test_add>
+template <migraphx::shape::type_t DType>
+struct test_add : verify_program<test_add<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {3}};
+        migraphx::shape s{DType, {8}};
         auto x = mm->add_parameter("x", s);
         auto y = mm->add_parameter("y", s);
         mm->add_instruction(migraphx::make_op("add"), x, y);
         return p;
     }
 };
+
+template struct test_add<migraphx::shape::fp8e4m3fnuz_type>;
+template struct test_add<migraphx::shape::half_type>;
+template struct test_add<migraphx::shape::float_type>;

test/verify/test_asin.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_asin : verify_program<test_asin>
+template <migraphx::shape::type_t DType>
+struct test_asin : verify_program<test_asin<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape s{DType, {16}};
         auto x = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("asin"), x);
         return p;
     }
 };
+
+template struct test_asin<migraphx::shape::float_type>;
+template struct test_asin<migraphx::shape::half_type>;
+template struct test_asin<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_asinh.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_asinh : verify_program<test_asinh>
+template <migraphx::shape::type_t DType>
+struct test_asinh : verify_program<test_asinh<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape s{DType, {16}};
         auto x = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("asinh"), x);
         return p;
     }
 };
+
+template struct test_asinh<migraphx::shape::float_type>;
+template struct test_asinh<migraphx::shape::half_type>;
+template struct test_asinh<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_atan.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_atan : verify_program<test_atan>
+template <migraphx::shape::type_t DType>
+struct test_atan : verify_program<test_atan<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape s{DType, {16}};
         auto x = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("atan"), x);
         return p;
     }
 };
+
+template struct test_atan<migraphx::shape::float_type>;
+template struct test_atan<migraphx::shape::half_type>;
+template struct test_atan<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_atanh.cpp

@@ -23,20 +23,24 @@
  */
 
 #include "verify_program.hpp"
+#include <migraphx/float8.hpp>
+#include <migraphx/half.hpp>
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_atanh : verify_program<test_atanh>
+template <typename CType>
+struct test_atanh : verify_program<test_atanh<CType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm                      = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape::type_t dtype = migraphx::shape::get_type<CType>();
+        migraphx::shape s{dtype, {16}};
         auto x       = mm->add_parameter("x", s);
-        auto min_val = mm->add_literal(-0.95f);
-        auto max_val = mm->add_literal(0.95f);
+        auto min_val = mm->add_literal(migraphx::literal{migraphx::shape{dtype}, {-0.95f}});
+        auto max_val = mm->add_literal(migraphx::literal{migraphx::shape{dtype}, {0.95f}});
         min_val =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {16}}}), min_val);
         max_val =
@@ -46,3 +50,7 @@ struct test_atanh : verify_program<test_atanh>
         return p;
     }
 };
+
+template struct test_atanh<float>;
+template struct test_atanh<migraphx::half>;
+template struct test_atanh<migraphx::fp8::fp8e4m3fnuz>;

test/verify/test_avg_pooling_1d.cpp

@@ -35,7 +35,7 @@ struct test_avg_pooling_1d : verify_program<test_avg_pooling_1d>
         auto* mm = p.get_main_module();
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5}});
-        auto op = migraphx::op::pooling{migraphx::op::pooling_mode::average, {0}, {1}, {3}};
+        auto op = migraphx::op::pooling{migraphx::op::pooling_mode::average, {0}, {1}, {3}, {1}};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_avg_pooling_3d.cpp

@@ -36,7 +36,7 @@ struct test_avg_pooling_3d : verify_program<test_avg_pooling_3d>
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
         auto op = migraphx::op::pooling{
-            migraphx::op::pooling_mode::average, {1, 1, 1}, {3, 3, 3}, {3, 3, 3}};
+            migraphx::op::pooling_mode::average, {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, {1, 1, 1}};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_avg_pooling_3d_opt.cpp

@@ -36,7 +36,7 @@ struct test_avg_pooling_3d_opt : verify_program<test_avg_pooling_3d_opt>
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 2, 3, 3, 3}});
         auto op = migraphx::op::pooling{
-            migraphx::op::pooling_mode::average, {0, 0, 0}, {1, 1, 1}, {3, 3, 3}};
+            migraphx::op::pooling_mode::average, {0, 0, 0}, {1, 1, 1}, {3, 3, 3}, {1, 1, 1}};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_avg_pooling_ceil_3d.cpp

@@ -37,7 +37,7 @@ struct test_avg_pooling_ceil_3d : verify_program<test_avg_pooling_ceil_3d>
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
         auto op = migraphx::op::pooling{
-            migraphx::op::pooling_mode::average, {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, true};
+            migraphx::op::pooling_mode::average, {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, {1, 1, 1}, true};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_avg_pooling_pad.cpp

@@ -36,7 +36,7 @@ struct test_avg_pooling_pad : verify_program<test_avg_pooling_pad>
         auto* mm = p.get_main_module();
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 7}});
-        auto op = migraphx::op::pooling{migraphx::op::pooling_mode::average, {2}, {1}, {3}};
+        auto op = migraphx::op::pooling{migraphx::op::pooling_mode::average, {2}, {1}, {3}, {1}};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_ceil.cpp

@@ -27,16 +27,21 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_ceil : verify_program<test_ceil>
+template <migraphx::shape::type_t DType>
+struct test_ceil : verify_program<test_ceil<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
 
-        migraphx::shape s{migraphx::shape::double_type, {2, 3, 4, 6}};
+        migraphx::shape s{DType, {2, 3, 4, 6}};
         auto param = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("ceil"), param);
         return p;
     };
 };
+
+template struct test_ceil<migraphx::shape::float_type>;
+template struct test_ceil<migraphx::shape::half_type>;
+template struct test_ceil<migraphx::shape::fp8e4m3fnuz_type>;