Merge branch 'develop' into jit-concat-pointwise

src/value.cpp

@@ -400,7 +400,7 @@ std::pair<value*, bool> value::insert(const value& v)
 {
     if(v.key.empty())
     {
-        if(!x)
+        if(not x)
             x = std::make_shared<array_value_holder>();
         get_array_impl(x).push_back(v);
         assert(this->if_array());
@@ -408,7 +408,7 @@ std::pair<value*, bool> value::insert(const value& v)
     }
     else
     {
-        if(!x)
+        if(not x)
             x = std::make_shared<object_value_holder>();
         auto p = x->if_object()->emplace(v.key, get_array_impl(x).size());
         if(p.second)
@@ -420,7 +420,7 @@ std::pair<value*, bool> value::insert(const value& v)
 value* value::insert(const value* pos, const value& v)
 {
     assert(v.key.empty());
-    if(!x)
+    if(not x)
         x = std::make_shared<array_value_holder>();
     auto&& a = get_array_impl(x);
     auto it  = a.insert(a.begin() + (pos - begin()), v);
@@ -466,7 +466,7 @@ bool compare(const value& x, const value& y, F f)
 
 value::type_t value::get_type() const
 {
-    if(!x)
+    if(not x)
         return null_type;
     return x->get_type();
 }

test/api/test_custom_op_gpu.cpp

@@ -55,7 +55,7 @@ struct simple_custom_op final : migraphx::experimental_custom_op_base
 
     virtual migraphx::shape compute_shape(migraphx::shapes inputs) const override
     {
-        if(!inputs[0].standard())
+        if(not inputs[0].standard())
         {
             throw std::runtime_error("first arg must be standard shaped");
         }

test/check_shapes_test.cpp

@@ -49,6 +49,6 @@ bool create_shapes(bool dynamic_allowed)
 
 TEST_CASE(allow_dynamic_shape) { EXPECT(create_shapes(true)); }
 
-TEST_CASE(fail_dynamic_shape) { EXPECT(!create_shapes(false)); }
+TEST_CASE(fail_dynamic_shape) { EXPECT(not create_shapes(false)); }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/eval_test.cpp

@@ -187,7 +187,7 @@ TEST_CASE(print_test)
     std::stringstream ss;
     ss << p;
     std::string s = ss.str();
-    EXPECT(!s.empty());
+    EXPECT(not s.empty());
 }
 
 TEST_CASE(param_test)

test/fpga/get_target_assignments.cpp

@@ -47,7 +47,7 @@ TEST_CASE(is_supported)
 {
     auto p       = create_program();
     auto targets = migraphx::get_targets();
-    EXPECT(!targets.empty());
+    EXPECT(not targets.empty());
     auto t = migraphx::make_target("fpga");
 
     const auto assignments = p.get_target_assignments({t});

test/include/basic_ops.hpp

@@ -112,12 +112,12 @@ struct mod_pass_op
     migraphx::shape compute_shape(std::vector<migraphx::shape> inputs,
                                   std::vector<migraphx::module_ref> mods) const
     {
-        if(!mods.empty())
+        if(not mods.empty())
         {
             auto out_shapes = mods[0]->get_output_shapes();
             return out_shapes[0];
         }
-        if(!inputs.empty())
+        if(not inputs.empty())
         {
             return inputs.front();
         }
@@ -186,9 +186,10 @@ struct nop
     migraphx::shape compute_shape(const std::vector<migraphx::shape>&) const { return {}; }
 };
 
-inline migraphx::literal get_2x2()
+inline migraphx::literal get_2x2(int base = 0)
 {
-    return migraphx::literal{{migraphx::shape::float_type, {2, 2}}, {1, 2, 3, 4}};
+    return migraphx::literal{{migraphx::shape::float_type, {2, 2}},
+                             {base + 1, base + 2, base + 3, base + 4}};
 }
 
 inline migraphx::literal get_2x2_transposed()

test/include/test.hpp

@@ -345,7 +345,7 @@ inline std::ostream& operator<<(std::ostream& os, const color& c)
 template <class T, class F>
 void failed(T x, const char* msg, const char* func, const char* file, int line, F f)
 {
-    if(!bool(x.value()))
+    if(not bool(x.value()))
     {
         std::cout << func << std::endl;
         std::cout << file << ":" << line << ":" << std::endl;

test/literal_test.cpp

@@ -39,8 +39,8 @@ TEST_CASE(literal_test)
     migraphx::literal l2 = l1; // NOLINT
     EXPECT(l1 == l2);
     EXPECT(l1.at<int>(0) == 1);
-    EXPECT(!l1.empty());
-    EXPECT(!l2.empty());
+    EXPECT(not l1.empty());
+    EXPECT(not l2.empty());
 
     migraphx::literal l3{};
     migraphx::literal l4{};

test/ref_ops_test.cpp

@@ -3988,7 +3988,8 @@ TEST_CASE(not_test)
         std::vector<char> results_vector;
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
         std::vector<bool> gold(data.size());
-        std::transform(data.begin(), data.end(), gold.begin(), [](bool n) -> bool { return !n; });
+        std::transform(
+            data.begin(), data.end(), gold.begin(), [](bool n) -> bool { return not n; });
         EXPECT(migraphx::verify_range(results_vector, gold));
     }
 }

test/rewrite_gelu_test.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 <migraphx/rewrite_gelu.hpp>
+#include <migraphx/dead_code_elimination.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/ref/target.hpp>
+#include <migraphx/op/convolution.hpp>
+#include <migraphx/op/reshape.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/ranges.hpp>
+#include <test.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/common.hpp>
+
+#include <migraphx/serialize.hpp>
+
+#include <migraphx/verify.hpp>
+
+TEST_CASE(bias_gelu)
+{
+    migraphx::shape s1{migraphx::shape::half_type, {2, 4, 8}};
+    migraphx::shape s2{migraphx::shape::half_type};
+    migraphx::module m1;
+    {
+        auto a    = m1.add_parameter("a", s1);
+        auto b    = m1.add_parameter("b", s1);
+        auto add1 = m1.add_instruction(migraphx::make_op("add"), a, b);
+        auto l1   = m1.add_literal(migraphx::literal{s2, {1.4140625f}});
+        auto div  = add_common_op(m1, migraphx::make_op("div"), {add1, l1});
+        auto erf  = m1.add_instruction(migraphx::make_op("erf"), div);
+        auto l2   = m1.add_literal(migraphx::literal{s2, {1.0f}});
+        auto add2 = add_common_op(m1, migraphx::make_op("add"), {erf, l2});
+        auto mul  = m1.add_instruction(migraphx::make_op("mul"), add1, add2);
+        auto l3   = m1.add_literal(migraphx::literal{s2, {0.5f}});
+        mul       = add_common_op(m1, migraphx::make_op("mul"), {mul, l3});
+        m1.add_return({mul});
+    }
+    migraphx::rewrite_gelu pass;
+    pass.apply(m1);
+    migraphx::dead_code_elimination dce;
+    dce.apply(m1);
+
+    migraphx::module m2;
+    {
+        auto a   = m2.add_parameter("a", s1);
+        auto b   = m2.add_parameter("b", s1);
+        auto add = m2.add_instruction(migraphx::make_op("add"), a, b);
+        auto l1  = m2.add_literal(migraphx::literal{s2, {1.702f}});
+        auto mul = add_common_op(m2, migraphx::make_op("mul"), {add, l1});
+        auto sig = m2.add_instruction(migraphx::make_op("neg"), mul);
+        sig      = m2.add_instruction(migraphx::make_op("exp"), sig);
+        auto l2  = m2.add_literal(migraphx::literal{s2, {1.0f}});
+        sig      = add_common_op(m2, migraphx::make_op("add"), {sig, l2});
+        sig      = m2.add_instruction(migraphx::make_op("div"), add, sig);
+        m2.add_return({sig});
+    }
+
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(non_bias_gelu)
+{
+    migraphx::shape s1{migraphx::shape::half_type, {2, 4, 8}};
+    migraphx::shape s2{migraphx::shape::half_type};
+    migraphx::module m1;
+    {
+        auto a    = m1.add_parameter("a", s1);
+        auto b    = m1.add_parameter("b", s1);
+        auto sub  = m1.add_instruction(migraphx::make_op("sub"), a, b);
+        auto l1   = m1.add_literal(migraphx::literal{s2, {1.4140625f}});
+        auto div  = add_common_op(m1, migraphx::make_op("div"), {sub, l1});
+        auto erf  = m1.add_instruction(migraphx::make_op("erf"), div);
+        auto l2   = m1.add_literal(migraphx::literal{s2, {1.0f}});
+        auto add2 = add_common_op(m1, migraphx::make_op("add"), {erf, l2});
+        auto mul  = m1.add_instruction(migraphx::make_op("mul"), sub, add2);
+        auto l3   = m1.add_literal(migraphx::literal{s2, {0.5f}});
+        mul       = add_common_op(m1, migraphx::make_op("mul"), {mul, l3});
+        m1.add_return({mul});
+    }
+    migraphx::rewrite_gelu pass;
+    pass.apply(m1);
+    migraphx::dead_code_elimination dce;
+    dce.apply(m1);
+
+    migraphx::module m2;
+    {
+        auto a   = m2.add_parameter("a", s1);
+        auto b   = m2.add_parameter("b", s1);
+        auto sub = m2.add_instruction(migraphx::make_op("sub"), a, b);
+        auto l1  = m2.add_literal(migraphx::literal{s2, {1.702f}});
+        auto mul = add_common_op(m2, migraphx::make_op("mul"), {sub, l1});
+        auto sig = m2.add_instruction(migraphx::make_op("neg"), mul);
+        sig      = m2.add_instruction(migraphx::make_op("exp"), sig);
+        auto l2  = m2.add_literal(migraphx::literal{s2, {1.0f}});
+        sig      = add_common_op(m2, migraphx::make_op("add"), {sig, l2});
+        sig      = m2.add_instruction(migraphx::make_op("div"), sub, sig);
+        m2.add_return({sig});
+    }
+
+    EXPECT(m1 == m2);
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/shape_test.cpp

@@ -43,7 +43,7 @@ TEST_CASE(test_shape_assign)
     migraphx::shape s1{migraphx::shape::float_type, {100, 32, 8, 8}};
     migraphx::shape s2 = s1; // NOLINT
     EXPECT(s1 == s2);
-    EXPECT(!(s1 != s2));
+    EXPECT(not(s1 != s2));
 }
 
 TEST_CASE(test_shape_packed_default)
@@ -325,7 +325,7 @@ TEST_CASE(test_shape_default_copy)
     migraphx::shape s1{};
     migraphx::shape s2{};
     EXPECT(s1 == s2);
-    EXPECT(!(s1 != s2));
+    EXPECT(not(s1 != s2));
 }
 
 TEST_CASE(test_shape_normalize_standard1)

test/simplify_algebra_test.cpp

@@ -30,7 +30,6 @@
 #include <migraphx/instruction.hpp>
 #include <basic_ops.hpp>
 #include <migraphx/make_op.hpp>
-
 #include <test.hpp>
 
 void run_pass(migraphx::module& m)
@@ -358,7 +357,33 @@ TEST_CASE(simplify_mul_add)
     EXPECT(m1 == m2);
 }
 
-TEST_CASE(simplify_inner_broadcast)
+TEST_CASE(simplify_dot_add)
+{
+    migraphx::module m1;
+    {
+        auto x   = m1.add_parameter("x", {migraphx::shape::float_type, {2, 2}});
+        auto one = m1.add_literal(get_2x2());
+        auto two = m1.add_literal(get_2x2(1));
+        auto sum = m1.add_instruction(migraphx::make_op("add"), one, x);
+        auto dot = m1.add_instruction(migraphx::make_op("dot"), sum, two);
+        m1.add_instruction(pass_op{}, dot);
+    }
+    run_pass(m1);
+
+    migraphx::module m2;
+    {
+        auto x    = m2.add_parameter("x", {migraphx::shape::float_type, {2, 2}});
+        auto one  = m2.add_literal(get_2x2());
+        auto two  = m2.add_literal(get_2x2(1));
+        auto dot1 = m2.add_instruction(migraphx::make_op("dot"), x, two);
+        auto dot2 = m2.add_instruction(migraphx::make_op("dot"), one, two);
+        auto sum  = m2.add_instruction(migraphx::make_op("add"), dot1, dot2);
+        m2.add_instruction(pass_op{}, sum);
+    }
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(simplify_inner_broadcast1)
 {
     auto b = migraphx::op::broadcast{1, {2, 1, 4, 5}};
     migraphx::module m1;
@@ -383,6 +408,31 @@ TEST_CASE(simplify_inner_broadcast)
     EXPECT(m1 == m2);
 }
 
+TEST_CASE(simplify_inner_broadcast2)
+{
+    auto b = migraphx::op::multibroadcast{{2, 1, 4, 5}};
+    migraphx::module m1;
+    {
+        auto x   = m1.add_parameter("x", {migraphx::shape::int32_type, {1, 1, 1, 1}});
+        auto y   = m1.add_parameter("y", {migraphx::shape::int32_type, {1, 1, 1, 1}});
+        auto xb  = m1.add_instruction(b, x);
+        auto yb  = m1.add_instruction(b, y);
+        auto sum = m1.add_instruction(migraphx::make_op("add"), xb, yb);
+        m1.add_instruction(pass_op{}, sum);
+    }
+    run_pass(m1);
+
+    migraphx::module m2;
+    {
+        auto x    = m2.add_parameter("x", {migraphx::shape::int32_type, {1, 1, 1, 1}});
+        auto y    = m2.add_parameter("y", {migraphx::shape::int32_type, {1, 1, 1, 1}});
+        auto sum  = m2.add_instruction(migraphx::make_op("add"), x, y);
+        auto sumb = m2.add_instruction(b, sum);
+        m2.add_instruction(pass_op{}, sumb);
+    }
+    EXPECT(m1 == m2);
+}
+
 TEST_CASE(simplify_add_conv1)
 {
     migraphx::module m;
@@ -1477,6 +1527,48 @@ TEST_CASE(simplify_dot_horiz_flipped)
     EXPECT(m1.sort() == m2.sort());
 }
 
+// test if contiguous is added as necessary for reshapes
+TEST_CASE(simplify_dot_horiz_reshape)
+{
+    auto s = migraphx::shape{migraphx::shape::int32_type, {3, 4, 4}};
+    migraphx::module m1;
+    {
+        auto input = m1.add_parameter("input", s);
+        auto a     = m1.add_literal(migraphx::generate_literal(s, 0));
+        auto b     = m1.add_literal(migraphx::generate_literal(s, 1));
+        auto x     = m1.add_instruction(migraphx::make_op("dot"), input, a);
+        auto y     = m1.add_instruction(migraphx::make_op("dot"), input, b);
+        auto x_rsp = m1.add_instruction(migraphx::make_op("reshape", {{"dims", {3, 4, 2, 2}}}), x);
+        auto y_rsp =
+            m1.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {2}}, {"steps", {2}}}), y);
+        auto sum = m1.add_instruction(migraphx::make_op("add"), {x_rsp, y_rsp});
+        m1.add_instruction(pass_op{}, sum);
+    }
+    run_pass(m1);
+
+    migraphx::module m2;
+    {
+        auto input  = m2.add_parameter("input", s);
+        auto a      = m2.add_literal(migraphx::generate_literal(s, 0));
+        auto b      = m2.add_literal(migraphx::generate_literal(s, 1));
+        auto concat = m2.add_instruction(migraphx::make_op("concat", {{"axis", 2}}), a, b);
+        auto dot    = m2.add_instruction(migraphx::make_op("dot"), input, concat);
+        auto x      = m2.add_instruction(
+            migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {4}}}), dot);
+        auto y = m2.add_instruction(
+            migraphx::make_op("slice", {{"axes", {2}}, {"starts", {4}}, {"ends", {8}}}), dot);
+        auto x_cont = m2.add_instruction(migraphx::make_op("contiguous"), x);
+        auto x_rsp =
+            m2.add_instruction(migraphx::make_op("reshape", {{"dims", {3, 4, 2, 2}}}), x_cont);
+        auto y_rsp =
+            m2.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {2}}, {"steps", {2}}}), y);
+        auto sum = m2.add_instruction(migraphx::make_op("add"), {x_rsp, y_rsp});
+        m2.add_instruction(pass_op{}, sum);
+    }
+
+    EXPECT(m1.sort() == m2.sort());
+}
+
 TEST_CASE(simplify_conv_horiz)
 {
     auto s  = migraphx::shape{migraphx::shape::int32_type, {8, 3, 64, 64}};
@@ -1782,13 +1874,19 @@ TEST_CASE(simplify_mul_slice_conv_horiz_fusion)
     }
     EXPECT(m1.sort() == m2.sort());
 }
-TEST_CASE(reorder_reshape_slice)
+
+template <std::size_t BS, bool TransposeInput>
+void reorder_reshape_slice()
 {
     std::vector<int64_t> perm0 = {0, 2, 1, 3};
     std::vector<int64_t> perm1 = {0, 2, 3, 1};
-    auto create_m1             = [&](std::size_t batch_size) {
-        migraphx::module m1;
-        auto s     = migraphx::shape{migraphx::shape::float_type, {batch_size, 128, 1920}};
+    migraphx::module m1;
+    {
+        auto s = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}};
+        if(TransposeInput)
+        {
+            s = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}, {165120, 1, 128}};
+        }
         auto input = m1.add_parameter("input", s);
         auto slc0  = m1.add_instruction(
             migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {640}}}), input);
@@ -1803,7 +1901,7 @@ TEST_CASE(reorder_reshape_slice)
         auto c1 = m1.add_instruction(migraphx::make_op("contiguous"), slc1);
         auto c2 = m1.add_instruction(migraphx::make_op("contiguous"), slc2);
 
-        std::vector<int64_t> lens = {static_cast<int64_t>(batch_size), 128, 10, 64};
+        std::vector<int64_t> lens = {static_cast<int64_t>(BS), 128, 10, 64};
         auto r0 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c0);
         auto r1 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c1);
         auto r2 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c2);
@@ -1815,16 +1913,23 @@ TEST_CASE(reorder_reshape_slice)
         auto sum = m1.add_instruction(migraphx::make_op("add"), t0, t1);
         auto ret = m1.add_instruction(migraphx::make_op("dot"), sum, t2);
         m1.add_return({ret});
-
-        return m1;
     };
 
-    auto create_m2 = [&](std::size_t batch_size) {
-        migraphx::module m2;
-        auto s     = migraphx::shape{migraphx::shape::float_type, {batch_size, 128, 1920}};
-        auto input = m2.add_parameter("input", s);
-        std::vector<int64_t> lens = {static_cast<int64_t>(batch_size), 128, 30, 64};
-        auto r = m2.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), input);
+    migraphx::module m2;
+    {
+        auto s = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}};
+        if(TransposeInput)
+        {
+            s = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}, {165120, 1, 128}};
+        }
+        auto input     = m2.add_parameter("input", s);
+        auto rsp_input = input;
+        if(TransposeInput)
+        {
+            rsp_input = m2.add_instruction(migraphx::make_op("contiguous"), {input});
+        }
+        std::vector<int64_t> lens = {static_cast<int64_t>(BS), 128, 30, 64};
+        auto r = m2.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), rsp_input);
 
         auto slc0 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {10}}}), r);
@@ -1843,27 +1948,25 @@ TEST_CASE(reorder_reshape_slice)
         auto sum = m2.add_instruction(migraphx::make_op("add"), t0, t1);
         auto ret = m2.add_instruction(migraphx::make_op("dot"), sum, t2);
         m2.add_return({ret});
-
-        return m2;
     };
-
-    auto test = [&](std::size_t batch_size) {
-        auto m1 = create_m1(batch_size);
-        run_pass(m1);
-        auto m2 = create_m2(batch_size);
-        EXPECT(m1.sort() == m2.sort());
-    };
-
-    test(1);
-    test(4);
-    test(8);
+    run_pass(m1);
+    EXPECT(m1.sort() == m2.sort());
 }
 
-TEST_CASE(reorder_reshape_slice_move_axis1)
+TEST_CASE_REGISTER(reorder_reshape_slice<1, true>); // test if contiguous is added as necessary if
+                                                    // input is transposed
+TEST_CASE_REGISTER(reorder_reshape_slice<4, true>);
+TEST_CASE_REGISTER(reorder_reshape_slice<8, true>);
+TEST_CASE_REGISTER(reorder_reshape_slice<1, false>);
+TEST_CASE_REGISTER(reorder_reshape_slice<4, false>);
+TEST_CASE_REGISTER(reorder_reshape_slice<8, false>);
+
+template <std::size_t BS>
+void reorder_reshape_slice_move_axis1()
 {
-    auto create_m1 = [](std::size_t batch_size) {
-        migraphx::module m1;
-        auto s = migraphx::shape{migraphx::shape::float_type, {batch_size, 256, 96}};
+    migraphx::module m1;
+    {
+        auto s                     = migraphx::shape{migraphx::shape::float_type, {BS, 256, 96}};
         std::vector<int64_t> perm0 = {0, 2, 1, 3};
         std::vector<int64_t> perm1 = {0, 2, 3, 1};
         auto input                 = m1.add_parameter("input", s);
@@ -1878,7 +1981,7 @@ TEST_CASE(reorder_reshape_slice_move_axis1)
         auto c1 = m1.add_instruction(migraphx::make_op("contiguous"), slc1);
         auto c2 = m1.add_instruction(migraphx::make_op("contiguous"), slc2);
 
-        std::vector<int64_t> lens = {static_cast<int64_t>(batch_size), 64, 4, 32};
+        std::vector<int64_t> lens = {static_cast<int64_t>(BS), 64, 4, 32};
         auto r0 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c0);
         auto r1 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c1);
         auto r2 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c2);
@@ -1890,50 +1993,45 @@ TEST_CASE(reorder_reshape_slice_move_axis1)
         auto sum = m1.add_instruction(migraphx::make_op("add"), t0, t1);
         auto ret = m1.add_instruction(migraphx::make_op("dot"), sum, t2);
         m1.add_return({ret});
-
-        return m1;
     };
 
-    auto create_m2 = [](std::size_t batch_size) {
-        migraphx::module m;
-        auto s = migraphx::shape{migraphx::shape::float_type, {batch_size, 256, 96}};
+    migraphx::module m2;
+    {
+        auto s                     = migraphx::shape{migraphx::shape::float_type, {BS, 256, 96}};
         std::vector<int64_t> perm0 = {0, 2, 1, 3};
         std::vector<int64_t> perm1 = {0, 2, 3, 1};
-        auto input                 = m.add_parameter("input", s);
-        std::vector<int64_t> lens  = {static_cast<int64_t>(batch_size), 64, 4, 96};
-        auto rsp  = m.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), input);
-        auto slc0 = m.add_instruction(
+        auto input                 = m2.add_parameter("input", s);
+        std::vector<int64_t> lens  = {static_cast<int64_t>(BS), 64, 4, 96};
+        auto rsp  = m2.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), input);
+        auto slc0 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {3}}, {"starts", {0}}, {"ends", {32}}}), rsp);
-        auto t0 = m.add_instruction(migraphx::make_op("transpose", {{"permutation", perm0}}), slc0);
-        auto slc1 = m.add_instruction(
+        auto t0 =
+            m2.add_instruction(migraphx::make_op("transpose", {{"permutation", perm0}}), slc0);
+        auto slc1 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {3}}, {"starts", {32}}, {"ends", {64}}}), rsp);
-        auto t1 = m.add_instruction(migraphx::make_op("transpose", {{"permutation", perm0}}), slc1);
-        auto slc2 = m.add_instruction(
+        auto t1 =
+            m2.add_instruction(migraphx::make_op("transpose", {{"permutation", perm0}}), slc1);
+        auto slc2 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {3}}, {"starts", {64}}, {"ends", {96}}}), rsp);
-        auto t2 = m.add_instruction(migraphx::make_op("transpose", {{"permutation", perm1}}), slc2);
-
-        auto sum = m.add_instruction(migraphx::make_op("add"), t0, t1);
-        auto ret = m.add_instruction(migraphx::make_op("dot"), sum, t2);
-        m.add_return({ret});
-
-        return m;
-    };
+        auto t2 =
+            m2.add_instruction(migraphx::make_op("transpose", {{"permutation", perm1}}), slc2);
 
-    auto test = [&](std::size_t batch_size) {
-        auto m1 = create_m1(batch_size);
-        auto m2 = create_m2(batch_size);
-        run_pass(m1);
-        EXPECT(m1.sort() == m2.sort());
+        auto sum = m2.add_instruction(migraphx::make_op("add"), t0, t1);
+        auto ret = m2.add_instruction(migraphx::make_op("dot"), sum, t2);
+        m2.add_return({ret});
     };
 
-    test(4);
-    test(8);
+    run_pass(m1);
+    EXPECT(m1.sort() == m2.sort());
 }
 
+TEST_CASE_REGISTER(reorder_reshape_slice_move_axis1<4>);
+TEST_CASE_REGISTER(reorder_reshape_slice_move_axis1<8>);
+
 TEST_CASE(reorder_reshape_slice_move_axis2)
 {
-    auto create_m1 = [] {
-        migraphx::module m1;
+    migraphx::module m1;
+    {
         migraphx::shape s{migraphx::shape::float_type, {128, 96}};
         auto input = m1.add_parameter("input", s);
         auto slc0  = m1.add_instruction(
@@ -1955,32 +2053,26 @@ TEST_CASE(reorder_reshape_slice_move_axis2)
         auto sum = m1.add_instruction(migraphx::make_op("add"), r0, r1);
         auto ret = m1.add_instruction(migraphx::make_op("mul"), sum, r2);
         m1.add_return({ret});
-
-        return m1;
     };
 
-    auto create_m2 = [] {
-        migraphx::module m;
+    migraphx::module m2;
+    {
         auto s                    = migraphx::shape{migraphx::shape::float_type, {128, 96}};
-        auto input                = m.add_parameter("input", s);
+        auto input                = m2.add_parameter("input", s);
         std::vector<int64_t> lens = {1, 16, 8, 96};
-        auto rsp  = m.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), input);
-        auto slc0 = m.add_instruction(
+        auto rsp  = m2.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), input);
+        auto slc0 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {3}}, {"starts", {0}}, {"ends", {32}}}), rsp);
-        auto slc1 = m.add_instruction(
+        auto slc1 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {3}}, {"starts", {32}}, {"ends", {64}}}), rsp);
-        auto slc2 = m.add_instruction(
+        auto slc2 = m2.add_instruction(
             migraphx::make_op("slice", {{"axes", {3}}, {"starts", {64}}, {"ends", {96}}}), rsp);
 
-        auto sum = m.add_instruction(migraphx::make_op("add"), slc0, slc1);
-        auto ret = m.add_instruction(migraphx::make_op("mul"), sum, slc2);
-        m.add_return({ret});
-
-        return m;
+        auto sum = m2.add_instruction(migraphx::make_op("add"), slc0, slc1);
+        auto ret = m2.add_instruction(migraphx::make_op("mul"), sum, slc2);
+        m2.add_return({ret});
     };
 
-    auto m1 = create_m1();
-    auto m2 = create_m2();
     run_pass(m1);
     EXPECT(m1.sort() == m2.sort());
 }
@@ -2020,15 +2112,14 @@ TEST_CASE(reorder_reshape_slice_not_apply)
     EXPECT(m1.sort() == m2.sort());
 }
 
-TEST_CASE(reorder_reshape_slice_diff_dims)
+template <std::size_t BS>
+void reorder_reshape_slice_diff_dims()
 {
-    auto create_m1 = [](std::size_t batch_size) {
-        migraphx::module m1;
-        auto s = migraphx::shape{migraphx::shape::float_type, {batch_size, 96, 96}};
-        std::vector<int64_t> perm0 = {0, 2, 1, 3};
-        std::vector<int64_t> perm1 = {0, 2, 3, 1};
-        auto input                 = m1.add_parameter("input", s);
-        auto slc0                  = m1.add_instruction(
+    migraphx::module m1;
+    {
+        auto s     = migraphx::shape{migraphx::shape::float_type, {BS, 96, 96}};
+        auto input = m1.add_parameter("input", s);
+        auto slc0  = m1.add_instruction(
             migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {32}}}), input);
         auto slc1 = m1.add_instruction(
             migraphx::make_op("slice", {{"axes", {2}}, {"starts", {32}}, {"ends", {64}}}), input);
@@ -2039,34 +2130,31 @@ TEST_CASE(reorder_reshape_slice_diff_dims)
         auto c1 = m1.add_instruction(migraphx::make_op("contiguous"), slc1);
         auto c2 = m1.add_instruction(migraphx::make_op("contiguous"), slc2);
 
-        std::vector<int64_t> lens  = {static_cast<int64_t>(batch_size), 32, 3, 32};
-        std::vector<int64_t> lens1 = {static_cast<int64_t>(batch_size), 48, 2, 32};
+        std::vector<int64_t> lens  = {static_cast<int64_t>(BS), 32, 3, 32};
+        std::vector<int64_t> lens1 = {static_cast<int64_t>(BS), 48, 2, 32};
         auto r0 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c0);
         auto r1 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens}}), c1);
         auto r2 = m1.add_instruction(migraphx::make_op("reshape", {{"dims", lens1}}), c2);
 
         m1.add_return({r0, r1, r2});
-
-        return m1;
     };
 
-    auto test = [&](std::size_t batch_size) {
-        auto m1 = create_m1(batch_size);
-        auto m2 = m1;
-        run_pass(m1);
-        EXPECT(m1.sort() == m2.sort());
-    };
-
-    test(4);
-    test(8);
+    auto m2 = m1;
+    run_pass(m1);
+    EXPECT(m1.sort() == m2.sort());
 }
 
-TEST_CASE(reorder_slice_trans)
+TEST_CASE_REGISTER(reorder_reshape_slice_diff_dims<4>);
+TEST_CASE_REGISTER(reorder_reshape_slice_diff_dims<8>);
+
+template <std::size_t BS>
+void reorder_slice_trans()
 {
     std::vector<int64_t> perm = {0, 2, 1};
-    auto create_m1            = [&](std::size_t batch_size) {
-        migraphx::module m1;
-        auto s     = migraphx::shape{migraphx::shape::float_type, {batch_size, 128, 1920}};
+
+    migraphx::module m1;
+    {
+        auto s     = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}};
         auto input = m1.add_parameter("input", s);
         auto slc0  = m1.add_instruction(
             migraphx::make_op("slice", {{"axes", {2}}, {"starts", {0}}, {"ends", {640}}}), input);
@@ -2084,13 +2172,11 @@ TEST_CASE(reorder_slice_trans)
         auto sum = m1.add_instruction(migraphx::make_op("add"), t0, t1);
         auto ret = m1.add_instruction(migraphx::make_op("mul"), sum, t2);
         m1.add_return({ret});
-
-        return m1;
     };
 
-    auto create_m2 = [&](std::size_t batch_size) {
-        migraphx::module m2;
-        auto s     = migraphx::shape{migraphx::shape::float_type, {batch_size, 128, 1920}};
+    migraphx::module m2;
+    {
+        auto s     = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}};
         auto input = m2.add_parameter("input", s);
         auto r = m2.add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), input);
 
@@ -2104,26 +2190,21 @@ TEST_CASE(reorder_slice_trans)
         auto sum = m2.add_instruction(migraphx::make_op("add"), slc0, slc1);
         auto ret = m2.add_instruction(migraphx::make_op("mul"), sum, slc2);
         m2.add_return({ret});
-
-        return m2;
     };
 
-    auto test = [&](std::size_t batch_size) {
-        auto m1 = create_m1(batch_size);
-        run_pass(m1);
-        auto m2 = create_m2(batch_size);
-        EXPECT(m1.sort() == m2.sort());
-    };
-
-    test(1);
-    test(8);
+    run_pass(m1);
+    EXPECT(m1.sort() == m2.sort());
 }
 
-TEST_CASE(reorder_slice_trans_diff_perm)
+TEST_CASE_REGISTER(reorder_slice_trans<1>);
+TEST_CASE_REGISTER(reorder_slice_trans<8>);
+
+template <std::size_t BS>
+void reorder_slice_trans_diff_perm()
 {
-    auto create_m1 = [](std::size_t batch_size) {
-        migraphx::module m1;
-        auto s = migraphx::shape{migraphx::shape::float_type, {batch_size, 128, 1920}};
+    migraphx::module m1;
+    {
+        auto s                     = migraphx::shape{migraphx::shape::float_type, {BS, 128, 1920}};
         std::vector<int64_t> perm0 = {0, 2, 1};
         std::vector<int64_t> perm1 = {0, 1, 2};
         auto input                 = m1.add_parameter("input", s);
@@ -2146,21 +2227,16 @@ TEST_CASE(reorder_slice_trans_diff_perm)
         auto sum = m1.add_instruction(migraphx::make_op("add"), t0, t1);
         auto ret = m1.add_instruction(migraphx::make_op("dot"), sum, t2);
         m1.add_return({ret});
-
-        return m1;
-    };
-
-    auto test = [&](std::size_t batch_size) {
-        auto m1 = create_m1(batch_size);
-        run_pass(m1);
-        auto m2 = m1;
-        EXPECT(m1.sort() == m2.sort());
     };
 
-    test(1);
-    test(4);
+    run_pass(m1);
+    auto m2 = m1;
+    EXPECT(m1.sort() == m2.sort());
 }
 
+TEST_CASE_REGISTER(reorder_slice_trans_diff_perm<1>);
+TEST_CASE_REGISTER(reorder_slice_trans_diff_perm<4>);
+
 TEST_CASE(reorder_slice_ins_deps)
 {
     auto create_module = [] {

test/verify/gemm_add_broadcast1.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>
+#include <migraphx/apply_alpha_beta.hpp>
+struct gemm_add_broadcast1 : verify_program<gemm_add_broadcast1>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape m1_shape{migraphx::shape::float_type, {1, 2, 3}};
+        migraphx::shape m2_shape{migraphx::shape::float_type, {1, 3, 4}};
+        migraphx::shape m3_shape{migraphx::shape::float_type, {1, 1, 4}};
+        auto l1 = mm->add_parameter("1", m1_shape);
+        auto l2 = mm->add_parameter("2", m2_shape);
+        auto l3 = mm->add_parameter("3", m3_shape);
+        auto l3_b =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {1, 2, 4}}}), l3);
+
+        auto dot = mm->add_instruction(migraphx::make_op("dot"), l1, l2);
+        mm->add_instruction(migraphx::make_op("add"), dot, l3_b);
+        return p;
+    }
+};

test/verify/gemm_add_broadcast2.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>
+#include <migraphx/apply_alpha_beta.hpp>
+struct gemm_add_broadcast2 : verify_program<gemm_add_broadcast2>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape m1_shape{migraphx::shape::float_type, {1, 2, 3}};
+        migraphx::shape m2_shape{migraphx::shape::float_type, {1, 3, 4}};
+        migraphx::shape m3_shape{migraphx::shape::float_type, {1, 2, 1}};
+        auto l1 = mm->add_parameter("1", m1_shape);
+        auto l2 = mm->add_parameter("2", m2_shape);
+        auto l3 = mm->add_parameter("3", m3_shape);
+        auto l3_b =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {1, 2, 4}}}), l3);
+
+        auto dot = mm->add_instruction(migraphx::make_op("dot"), l1, l2);
+        mm->add_instruction(migraphx::make_op("add"), dot, l3_b);
+        return p;
+    }
+};

test/verify/run_verify.cpp

@@ -169,7 +169,7 @@ void run_verify::verify(const std::string& name, const migraphx::program& p) con
     for(const auto& tname : migraphx::get_targets())
     {
         // TODO(varunsh): once verify tests can run, remove fpga
-        if(tname == "ref" || tname == "fpga")
+        if(tname == "ref" or tname == "fpga")
             continue;
 
         // if tests disabled, skip running it

test/verify/test_add_gelu_half.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 test_add_gelu_half : verify_program<test_add_gelu_half>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        std::vector<size_t> input_lens{1, 1, 5};
+        auto x     = mm->add_parameter("x", {migraphx::shape::half_type, input_lens});
+        auto y     = mm->add_parameter("y", {migraphx::shape::half_type, input_lens});
+        auto half  = mm->add_literal(migraphx::literal{{migraphx::shape::half_type}, {0.5f}});
+        auto one   = mm->add_literal(migraphx::literal{{migraphx::shape::half_type}, {1.0f}});
+        auto sqrt2 = mm->add_literal(migraphx::literal{{migraphx::shape::half_type}, {M_SQRT2}});
+        auto add   = mm->add_instruction(migraphx::make_op("add"), x, y);
+        auto half_mbcast = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), half);
+        auto mul_half     = mm->add_instruction(migraphx::make_op("mul"), add, half_mbcast);
+        auto sqrt2_mbcast = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), sqrt2);
+        auto div        = mm->add_instruction(migraphx::make_op("div"), add, sqrt2_mbcast);
+        auto erf        = mm->add_instruction(migraphx::make_op("erf"), div);
+        auto one_mbcast = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), one);
+        auto add_one = mm->add_instruction(migraphx::make_op("add"), erf, one_mbcast);
+        mm->add_instruction(migraphx::make_op("mul"), mul_half, add_one);
+        return p;
+    }
+};

tools/include/operation.hpp

@@ -560,7 +560,7 @@ lifetime get_lifetime_op(const T&)
 
     inline bool operator!=(const operation& x, const operation& y)
 {
-    return !(x == y);
+    return not(x == y);
 }
 
 inline value

tools/te.py

@@ -136,7 +136,7 @@ private:
         template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
         private_detail_te_handle_type (PrivateDetailTypeErasedT value,
                 typename std::enable_if<
-                    !std::is_reference<PrivateDetailTypeErasedU>::value,
+                    not std::is_reference<PrivateDetailTypeErasedU>::value,
                     int
                 >::type * = nullptr) noexcept :
             private_detail_te_value (std::move(value))
@@ -178,7 +178,7 @@ private:
     private_detail_te_handle_base_type & private_detail_te_get_handle ()
     {
         assert(private_detail_te_handle_mem_var != nullptr); 
-        if (!private_detail_te_handle_mem_var.unique())
+        if (not private_detail_te_handle_mem_var.unique())
             private_detail_te_handle_mem_var = private_detail_te_handle_mem_var->clone();
         return *private_detail_te_handle_mem_var;
     }