Refactor program to module (#684)

* code backup

* clang format

* change corresponding tool files

* clang format
Co-authored-by: mvermeulen <5479696+mvermeulen@users.noreply.github.com>

test/verify/test_add.cpp

@@ -9,10 +9,11 @@ struct test_add : verify_program<test_add>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {3}};
-        auto x = p.add_parameter("x", s);
-        auto y = p.add_parameter("y", s);
-        p.add_instruction(migraphx::op::add{}, x, y);
+        auto x = mm->add_parameter("x", s);
+        auto y = mm->add_parameter("y", s);
+        mm->add_instruction(migraphx::op::add{}, x, y);
         return p;
     }
 };

test/verify/test_add_broadcast.cpp

@@ -10,11 +10,12 @@ struct test_add_broadcast : verify_program<test_add_broadcast>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {3}};
-        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 2, 3}});
-        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {2, 2}});
-        auto by = p.add_instruction(migraphx::op::broadcast{0, x->get_shape().lens()}, y);
-        p.add_instruction(migraphx::op::add{}, x, by);
+        auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 2, 3}});
+        auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {2, 2}});
+        auto by = mm->add_instruction(migraphx::op::broadcast{0, x->get_shape().lens()}, y);
+        mm->add_instruction(migraphx::op::add{}, x, by);
         return p;
     }
 };

test/verify/test_add_broadcast2.cpp

@@ -10,11 +10,12 @@ struct test_add_broadcast2 : verify_program<test_add_broadcast2>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {3}};
-        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 3, 4}});
-        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {3}});
-        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
-        p.add_instruction(migraphx::op::add{}, x, by);
+        auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 3, 4}});
+        auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {3}});
+        auto by = mm->add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
+        mm->add_instruction(migraphx::op::add{}, x, by);
         return p;
     }
 };

test/verify/test_add_broadcast3.cpp

@@ -10,11 +10,12 @@ struct test_add_broadcast3 : verify_program<test_add_broadcast3>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {3}};
-        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 4, 5}});
-        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {4}});
-        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
-        p.add_instruction(migraphx::op::add{}, x, by);
+        auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 4, 5}});
+        auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {4}});
+        auto by = mm->add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
+        mm->add_instruction(migraphx::op::add{}, x, by);
         return p;
     }
 };

test/verify/test_add_broadcast4.cpp

@@ -10,11 +10,12 @@ struct test_add_broadcast4 : verify_program<test_add_broadcast4>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {3}};
-        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 3, 5}});
-        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {3}});
-        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
-        p.add_instruction(migraphx::op::add{}, x, by);
+        auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 3, 5}});
+        auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {3}});
+        auto by = mm->add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
+        mm->add_instruction(migraphx::op::add{}, x, by);
         return p;
     }
 };

test/verify/test_add_broadcast5.cpp

@@ -10,11 +10,12 @@ struct test_add_broadcast5 : verify_program<test_add_broadcast5>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {3}};
-        auto x  = p.add_parameter("x", {migraphx::shape::float_type, {2, 4, 8}});
-        auto y  = p.add_parameter("y", {migraphx::shape::float_type, {4}});
-        auto by = p.add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
-        p.add_instruction(migraphx::op::add{}, x, by);
+        auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 4, 8}});
+        auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {4}});
+        auto by = mm->add_instruction(migraphx::op::broadcast{1, x->get_shape().lens()}, y);
+        mm->add_instruction(migraphx::op::add{}, x, by);
         return p;
     }
 };

test/verify/test_add_gelu.cpp

@@ -9,21 +9,22 @@ struct test_add_gelu : verify_program<test_add_gelu>
     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            = p.add_parameter("x", {migraphx::shape::float_type, input_lens});
-        auto y            = p.add_parameter("y", {migraphx::shape::float_type, input_lens});
-        auto half         = p.add_literal(0.5f);
-        auto one          = p.add_literal(1.0f);
-        auto sqrt2        = p.add_literal(static_cast<float>(M_SQRT2));
-        auto add          = p.add_instruction(migraphx::op::add{}, x, y);
-        auto half_mbcast  = p.add_instruction(migraphx::op::multibroadcast{input_lens}, half);
-        auto mul_half     = p.add_instruction(migraphx::op::mul{}, add, half_mbcast);
-        auto sqrt2_mbcast = p.add_instruction(migraphx::op::multibroadcast{input_lens}, sqrt2);
-        auto div          = p.add_instruction(migraphx::op::div{}, add, sqrt2_mbcast);
-        auto erf          = p.add_instruction(migraphx::op::erf{}, div);
-        auto one_mbcast   = p.add_instruction(migraphx::op::multibroadcast{input_lens}, one);
-        auto add_one      = p.add_instruction(migraphx::op::add{}, erf, one_mbcast);
-        p.add_instruction(migraphx::op::mul{}, mul_half, add_one);
+        auto x            = mm->add_parameter("x", {migraphx::shape::float_type, input_lens});
+        auto y            = mm->add_parameter("y", {migraphx::shape::float_type, input_lens});
+        auto half         = mm->add_literal(0.5f);
+        auto one          = mm->add_literal(1.0f);
+        auto sqrt2        = mm->add_literal(static_cast<float>(M_SQRT2));
+        auto add          = mm->add_instruction(migraphx::op::add{}, x, y);
+        auto half_mbcast  = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, half);
+        auto mul_half     = mm->add_instruction(migraphx::op::mul{}, add, half_mbcast);
+        auto sqrt2_mbcast = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, sqrt2);
+        auto div          = mm->add_instruction(migraphx::op::div{}, add, sqrt2_mbcast);
+        auto erf          = mm->add_instruction(migraphx::op::erf{}, div);
+        auto one_mbcast   = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, one);
+        auto add_one      = mm->add_instruction(migraphx::op::add{}, erf, one_mbcast);
+        mm->add_instruction(migraphx::op::mul{}, mul_half, add_one);
         return p;
     }
 };

test/verify/test_add_half.cpp

@@ -9,10 +9,11 @@ struct test_add_half : verify_program<test_add_half>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::half_type, {3}};
-        auto x = p.add_parameter("x", s);
-        auto y = p.add_parameter("y", s);
-        p.add_instruction(migraphx::op::add{}, x, y);
+        auto x = mm->add_parameter("x", s);
+        auto y = mm->add_parameter("y", s);
+        mm->add_instruction(migraphx::op::add{}, x, y);
         return p;
     }
 };

test/verify/test_add_relu.cpp

@@ -9,10 +9,11 @@ struct test_add_relu : verify_program<test_add_relu>
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto x   = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto y   = p.add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto add = p.add_instruction(migraphx::op::add{}, x, y);
-        p.add_instruction(migraphx::op::relu{}, add);
+        auto* mm = p.get_main_module();
+        auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto y = mm->add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto add = mm->add_instruction(migraphx::op::add{}, x, y);
+        mm->add_instruction(migraphx::op::relu{}, add);
         return p;
     }
 };

test/verify/test_add_sigmoid.cpp

@@ -9,10 +9,11 @@ struct test_add_sigmoid : verify_program<test_add_sigmoid>
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto x   = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto y   = p.add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto add = p.add_instruction(migraphx::op::add{}, x, y);
-        p.add_instruction(migraphx::op::sigmoid{}, add);
+        auto* mm = p.get_main_module();
+        auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto y = mm->add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto add = mm->add_instruction(migraphx::op::add{}, x, y);
+        mm->add_instruction(migraphx::op::sigmoid{}, add);
         return p;
     }
 };

test/verify/test_add_tanh.cpp

@@ -9,10 +9,11 @@ struct test_add_tanh : verify_program<test_add_tanh>
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto x   = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto y   = p.add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto add = p.add_instruction(migraphx::op::add{}, x, y);
-        p.add_instruction(migraphx::op::tanh{}, add);
+        auto* mm = p.get_main_module();
+        auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto y = mm->add_parameter("y", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto add = mm->add_instruction(migraphx::op::add{}, x, y);
+        mm->add_instruction(migraphx::op::tanh{}, add);
         return p;
     }
 };

test/verify/test_arg_ops.cpp

@@ -10,9 +10,10 @@ struct test_arg_ops : verify_program<test_arg_ops<T, Axis>>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::float_type, {2, 3, 4, 1025}};
-        auto param = p.add_parameter("data", s);
-        p.add_instruction(T{Axis}, param);
+        auto param = mm->add_parameter("data", s);
+        mm->add_instruction(T{Axis}, param);
 
         return p;
     }

test/verify/test_asin.cpp

@@ -9,9 +9,10 @@ struct test_asin : verify_program<test_asin>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::double_type, {16}};
-        auto x = p.add_parameter("x", s);
-        p.add_instruction(migraphx::op::asin{}, x);
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(migraphx::op::asin{}, x);
         return p;
     }
 };

test/verify/test_asinh.cpp

@@ -9,9 +9,10 @@ struct test_asinh : verify_program<test_asinh>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::double_type, {16}};
-        auto x = p.add_parameter("x", s);
-        p.add_instruction(migraphx::op::asinh{}, x);
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(migraphx::op::asinh{}, x);
         return p;
     }
 };

test/verify/test_atan.cpp

@@ -9,9 +9,10 @@ struct test_atan : verify_program<test_atan>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::double_type, {16}};
-        auto x = p.add_parameter("x", s);
-        p.add_instruction(migraphx::op::atan{}, x);
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(migraphx::op::atan{}, x);
         return p;
     }
 };

test/verify/test_atanh.cpp

@@ -9,14 +9,15 @@ struct test_atanh : verify_program<test_atanh>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::double_type, {16}};
-        auto x       = p.add_parameter("x", s);
-        auto min_val = p.add_literal(-0.95);
-        auto max_val = p.add_literal(0.95);
-        min_val      = p.add_instruction(migraphx::op::multibroadcast{{16}}, min_val);
-        max_val      = p.add_instruction(migraphx::op::multibroadcast{{16}}, max_val);
-        auto cx      = p.add_instruction(migraphx::op::clip{}, x, min_val, max_val);
-        p.add_instruction(migraphx::op::atanh{}, cx);
+        auto x       = mm->add_parameter("x", s);
+        auto min_val = mm->add_literal(-0.95);
+        auto max_val = mm->add_literal(0.95);
+        min_val      = mm->add_instruction(migraphx::op::multibroadcast{{16}}, min_val);
+        max_val      = mm->add_instruction(migraphx::op::multibroadcast{{16}}, max_val);
+        auto cx      = mm->add_instruction(migraphx::op::clip{}, x, min_val, max_val);
+        mm->add_instruction(migraphx::op::atanh{}, cx);
         return p;
     }
 };

test/verify/test_avg_pooling_1d.cpp

@@ -9,9 +9,11 @@ struct test_avg_pooling_1d : verify_program<test_avg_pooling_1d>
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5}});
-        auto op    = migraphx::op::pooling{"average", {0}, {1}, {3}};
-        p.add_instruction(op, input);
+        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{"average", {0}, {1}, {3}};
+        mm->add_instruction(op, input);
         return p;
     }
 };

test/verify/test_avg_pooling_3d.cpp

@@ -9,10 +9,11 @@ struct test_avg_pooling_3d : verify_program<test_avg_pooling_3d>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         auto input =
-            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
         auto op = migraphx::op::pooling{"average", {1, 1, 1}, {3, 3, 3}, {3, 3, 3}};
-        p.add_instruction(op, input);
+        mm->add_instruction(op, input);
         return p;
     }
 };

test/verify/test_avg_pooling_3d_opt.cpp

@@ -9,10 +9,11 @@ struct test_avg_pooling_3d_opt : verify_program<test_avg_pooling_3d_opt>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         auto input =
-            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 2, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 2, 3, 3, 3}});
         auto op = migraphx::op::pooling{"average", {0, 0, 0}, {1, 1, 1}, {3, 3, 3}};
-        p.add_instruction(op, input);
+        mm->add_instruction(op, input);
         return p;
     }
 };

test/verify/test_avg_pooling_ceil_3d.cpp

@@ -9,10 +9,11 @@ struct test_avg_pooling_ceil_3d : verify_program<test_avg_pooling_ceil_3d>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         auto input =
-            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
         auto op = migraphx::op::pooling{"average", {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, true};
-        p.add_instruction(op, input);
+        mm->add_instruction(op, input);
         return p;
     }
 };