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_conv.cpp

@@ -9,11 +9,12 @@ struct test_conv : verify_program<test_conv>
     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, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        p.add_instruction(migraphx::op::convolution{}, input, weights);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        mm->add_instruction(migraphx::op::convolution{}, input, weights);
         return p;
     }
 };

test/verify/test_conv2.cpp

@@ -9,11 +9,12 @@ struct test_conv2 : verify_program<test_conv2>
     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, 512, 28, 28}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 512, 28, 28}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}});
-        p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, input, weights);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}});
+        mm->add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, input, weights);
         return p;
     }
 };

test/verify/test_conv3d.cpp

@@ -9,11 +9,12 @@ struct test_conv3d : verify_program<test_conv3d>
     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, 3, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3, 3}});
-        p.add_instruction(
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3, 3}});
+        mm->add_instruction(
             migraphx::op::convolution{{0, 0, 0}, {1, 1, 1}, {1, 1, 1}}, input, weights);
         return p;
     }

test/verify/test_conv_add.cpp

@@ -9,16 +9,17 @@ struct test_conv_add : verify_program<test_conv_add>
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto x = p.add_parameter("x", {migraphx::shape::float_type, {1, 8, 4, 4}});
-        auto w = p.add_literal(
+        auto* mm = p.get_main_module();
+        auto x   = mm->add_parameter("x", {migraphx::shape::float_type, {1, 8, 4, 4}});
+        auto w   = mm->add_literal(
             migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 3, 3}}, 1));
-        auto y = p.add_parameter("y", {migraphx::shape::float_type, {1, 8, 4, 4}});
-        auto v = p.add_literal(
+        auto y = mm->add_parameter("y", {migraphx::shape::float_type, {1, 8, 4, 4}});
+        auto v = mm->add_literal(
             migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 3, 3}}, 2));
-        auto conv1 = p.add_instruction(migraphx::op::convolution{}, x, w);
-        auto conv2 = p.add_instruction(migraphx::op::convolution{}, y, v);
-        auto sum   = p.add_instruction(migraphx::op::add{}, conv1, conv2);
-        p.add_instruction(migraphx::op::exp{}, sum);
+        auto conv1 = mm->add_instruction(migraphx::op::convolution{}, x, w);
+        auto conv2 = mm->add_instruction(migraphx::op::convolution{}, y, v);
+        auto sum   = mm->add_instruction(migraphx::op::add{}, conv1, conv2);
+        mm->add_instruction(migraphx::op::exp{}, sum);
         return p;
     }
 };

test/verify/test_conv_add_1x1_diff_strides.cpp

@@ -9,16 +9,17 @@ struct test_conv_add_1x1_diff_strides : verify_program<test_conv_add_1x1_diff_st
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto x = p.add_parameter("x", {migraphx::shape::float_type, {1, 8, 2, 2}});
-        auto w = p.add_literal(
+        auto* mm = p.get_main_module();
+        auto x   = mm->add_parameter("x", {migraphx::shape::float_type, {1, 8, 2, 2}});
+        auto w   = mm->add_literal(
             migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 1, 1}}, 1));
-        auto y = p.add_parameter("y", {migraphx::shape::float_type, {1, 8, 4, 4}});
-        auto v = p.add_literal(
+        auto y = mm->add_parameter("y", {migraphx::shape::float_type, {1, 8, 4, 4}});
+        auto v = mm->add_literal(
             migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 1, 1}}, 2));
-        auto conv1 = p.add_instruction(migraphx::op::convolution{}, x, w);
-        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}}, y, v);
-        auto sum   = p.add_instruction(migraphx::op::add{}, conv1, conv2);
-        p.add_instruction(migraphx::op::exp{}, sum);
+        auto conv1 = mm->add_instruction(migraphx::op::convolution{}, x, w);
+        auto conv2 = mm->add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}}, y, v);
+        auto sum   = mm->add_instruction(migraphx::op::add{}, conv1, conv2);
+        mm->add_instruction(migraphx::op::exp{}, sum);
         return p;
     }
 };

test/verify/test_conv_bias_clipped_relu.cpp

@@ -10,23 +10,24 @@ struct test_conv_bias_clipped_relu : verify_program<test_conv_bias_clipped_relu>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         std::vector<size_t> input_lens{4, 3, 3, 3};
         auto input =
-            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
         auto l0   = migraphx::literal{migraphx::shape{migraphx::shape::float_type, {4}},
                                     {2.0f, 2.0f, 2.0f, 2.0f}};
-        auto bias = p.add_literal(l0);
-        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
+        auto bias = mm->add_literal(l0);
+        auto conv = mm->add_instruction(migraphx::op::convolution{}, input, weights);
         auto bcast_add =
-            p.add_instruction(migraphx::op::broadcast{1, conv->get_shape().lens()}, bias);
-        auto bias_add = p.add_instruction(migraphx::op::add{}, conv, bcast_add);
-        auto min_val  = p.add_literal(0.0f);
-        auto max_val  = p.add_literal(6.0f);
-        min_val       = p.add_instruction(migraphx::op::multibroadcast{input_lens}, min_val);
-        max_val       = p.add_instruction(migraphx::op::multibroadcast{input_lens}, max_val);
-        p.add_instruction(migraphx::op::clip{}, bias_add, min_val, max_val);
+            mm->add_instruction(migraphx::op::broadcast{1, conv->get_shape().lens()}, bias);
+        auto bias_add = mm->add_instruction(migraphx::op::add{}, conv, bcast_add);
+        auto min_val  = mm->add_literal(0.0f);
+        auto max_val  = mm->add_literal(6.0f);
+        min_val       = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, min_val);
+        max_val       = mm->add_instruction(migraphx::op::multibroadcast{input_lens}, max_val);
+        mm->add_instruction(migraphx::op::clip{}, bias_add, min_val, max_val);
         return p;
     }
 };

test/verify/test_conv_bn.cpp

@@ -9,18 +9,20 @@ struct test_conv_bn : verify_program<test_conv_bn>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
 
         migraphx::shape xs{migraphx::shape::float_type, {1, 3, 224, 224}};
         migraphx::shape ws{migraphx::shape::float_type, {64, 3, 7, 7}};
         migraphx::shape vars{migraphx::shape::float_type, {64}};
-        auto x        = p.add_parameter("x", xs);
-        auto w        = p.add_parameter("w", ws);
-        auto conv     = p.add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
-        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        p.add_instruction(migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
+        auto x     = mm->add_parameter("x", xs);
+        auto w     = mm->add_parameter("w", ws);
+        auto conv  = mm->add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
+        auto scale = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
+        auto bias  = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
+        auto mean  = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
+        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
+        mm->add_instruction(
+            migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
         return p;
     }
 };

test/verify/test_conv_bn_add.cpp

@@ -12,11 +12,12 @@
 //                                             std::size_t seed = 1)
 //     {
 //         migraphx::shape vars{migraphx::shape::float_type, {channels}};
-//         auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 + seed)));
-//         auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2 + seed)));
-//         auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3 + seed)));
-//         auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + seed)));
-//         return p.add_instruction(
+//         auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 +
+//         seed))); auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2
+//         + seed))); auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars,
+//         3 + seed))); auto variance =
+//         mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + seed))); return
+//         mm->add_instruction(
 //             migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
 //     }
 
@@ -25,20 +26,20 @@
 //         migraphx::program p;
 //         std::size_t ichannels = 64;
 //         std::size_t ochannels = 256;
-//         auto x     = p.add_parameter("x", {migraphx::shape::float_type, {1, ichannels, 56, 56}});
-//         auto w     = p.add_literal(migraphx::generate_literal(
+//         auto x     = mm->add_parameter("x", {migraphx::shape::float_type, {1, ichannels, 56,
+//         56}}); auto w     = mm->add_literal(migraphx::generate_literal(
 //             {migraphx::shape::float_type, {ochannels, ichannels, 1, 1}}, 1));
-//         auto y     = p.add_parameter("y", {migraphx::shape::float_type, {1, ichannels, 56, 56}});
-//         auto v     = p.add_literal(migraphx::generate_literal(
+//         auto y     = mm->add_parameter("y", {migraphx::shape::float_type, {1, ichannels, 56,
+//         56}}); auto v     = mm->add_literal(migraphx::generate_literal(
 //             {migraphx::shape::float_type, {ochannels, ichannels, 1, 1}}, 2));
-//         auto relu1 = p.add_instruction(migraphx::op::relu{}, x);
-//         auto conv1 = p.add_instruction(migraphx::op::convolution{}, relu1, w);
+//         auto relu1 = mm->add_instruction(migraphx::op::relu{}, x);
+//         auto conv1 = mm->add_instruction(migraphx::op::convolution{}, relu1, w);
 //         auto bn1   = add_bn(p, conv1, ochannels, 1);
-//         auto relu2 = p.add_instruction(migraphx::op::relu{}, y);
-//         auto conv2 = p.add_instruction(migraphx::op::convolution{}, relu2, v);
+//         auto relu2 = mm->add_instruction(migraphx::op::relu{}, y);
+//         auto conv2 = mm->add_instruction(migraphx::op::convolution{}, relu2, v);
 //         auto bn2   = add_bn(p, conv2, ochannels, 1);
-//         auto sum   = p.add_instruction(migraphx::op::add{}, bn1, bn2);
-//         p.add_instruction(migraphx::op::relu{}, sum);
+//         auto sum   = mm->add_instruction(migraphx::op::add{}, bn1, bn2);
+//         mm->add_instruction(migraphx::op::relu{}, sum);
 //         return p;
 //     }
 // };

test/verify/test_conv_bn_relu_pooling.cpp

@@ -9,21 +9,22 @@ struct test_conv_bn_relu_pooling : verify_program<test_conv_bn_relu_pooling>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
 
         migraphx::shape xs{migraphx::shape::float_type, {1, 3, 224, 224}};
         migraphx::shape ws{migraphx::shape::float_type, {64, 3, 7, 7}};
         migraphx::shape vars{migraphx::shape::float_type, {64}};
-        auto x        = p.add_parameter("x", xs);
-        auto w        = p.add_parameter("w", ws);
-        auto conv     = p.add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
-        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        auto bn       = p.add_instruction(
+        auto x     = mm->add_parameter("x", xs);
+        auto w     = mm->add_parameter("w", ws);
+        auto conv  = mm->add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
+        auto scale = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
+        auto bias  = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
+        auto mean  = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
+        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
+        auto bn       = mm->add_instruction(
             migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
-        auto relu = p.add_instruction(migraphx::op::relu{}, bn);
-        p.add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
+        auto relu = mm->add_instruction(migraphx::op::relu{}, bn);
+        mm->add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
         return p;
     }
 };

test/verify/test_conv_bn_relu_pooling2.cpp

@@ -9,34 +9,36 @@ struct test_conv_bn_relu_pooling2 : verify_program<test_conv_bn_relu_pooling2>
     static migraphx::instruction_ref
     add_bn(migraphx::program& p, migraphx::instruction_ref x, std::size_t channels)
     {
+        auto* mm = p.get_main_module();
         migraphx::shape vars{migraphx::shape::float_type, {channels}};
-        auto scale = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 + channels)));
-        auto bias  = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2 + channels)));
-        auto mean  = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3 + channels)));
+        auto scale = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 + channels)));
+        auto bias  = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2 + channels)));
+        auto mean  = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3 + channels)));
         auto variance =
-            p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + channels)));
-        return p.add_instruction(
+            mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + channels)));
+        return mm->add_instruction(
             migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
     }
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
 
         migraphx::shape xs1{migraphx::shape::float_type, {1, 512, 7, 7}};
         migraphx::shape xs2{migraphx::shape::float_type, {1, 1024, 14, 14}};
         migraphx::shape ws1{migraphx::shape::float_type, {2048, 512, 1, 1}};
         migraphx::shape ws2{migraphx::shape::float_type, {2048, 1024, 1, 1}};
-        auto x1    = p.add_parameter("x1", xs1);
-        auto w1    = p.add_parameter("w1", ws1);
-        auto conv1 = p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, x1, w1);
+        auto x1    = mm->add_parameter("x1", xs1);
+        auto w1    = mm->add_parameter("w1", ws1);
+        auto conv1 = mm->add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, x1, w1);
         auto bn1   = add_bn(p, conv1, 2048);
-        auto x2    = p.add_parameter("x2", xs2);
-        auto w2    = p.add_parameter("w2", ws2);
-        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}, {1, 1}}, x2, w2);
+        auto x2    = mm->add_parameter("x2", xs2);
+        auto w2    = mm->add_parameter("w2", ws2);
+        auto conv2 = mm->add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}, {1, 1}}, x2, w2);
         auto bn2   = add_bn(p, conv2, 2048);
-        auto add   = p.add_instruction(migraphx::op::add{}, bn1, bn2);
-        auto relu  = p.add_instruction(migraphx::op::relu{}, add);
-        p.add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
+        auto add   = mm->add_instruction(migraphx::op::add{}, bn1, bn2);
+        auto relu  = mm->add_instruction(migraphx::op::relu{}, add);
+        mm->add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
         return p;
     }
 };

test/verify/test_conv_pooling.cpp

@@ -9,13 +9,14 @@ struct test_conv_pooling : verify_program<test_conv_pooling>
     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, 3, 32, 32}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 32, 32}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto conv    = p.add_instruction(migraphx::op::convolution{}, input, weights);
-        auto pooling = p.add_instruction(migraphx::op::pooling{"max"}, conv);
-        p.add_instruction(migraphx::op::relu{}, pooling);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto conv    = mm->add_instruction(migraphx::op::convolution{}, input, weights);
+        auto pooling = mm->add_instruction(migraphx::op::pooling{"max"}, conv);
+        mm->add_instruction(migraphx::op::relu{}, pooling);
         return p;
     }
 };

test/verify/test_conv_relu.cpp

@@ -9,12 +9,13 @@ struct test_conv_relu : verify_program<test_conv_relu>
     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, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
-        p.add_instruction(migraphx::op::relu{}, conv);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto conv = mm->add_instruction(migraphx::op::convolution{}, input, weights);
+        mm->add_instruction(migraphx::op::relu{}, conv);
         return p;
     }
 };

test/verify/test_conv_relu_half.cpp

@@ -9,12 +9,13 @@ struct test_conv_relu_half : verify_program<test_conv_relu_half>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         auto input =
-            p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
-        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
-        p.add_instruction(migraphx::op::relu{}, conv);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
+        auto conv = mm->add_instruction(migraphx::op::convolution{}, input, weights);
+        mm->add_instruction(migraphx::op::relu{}, conv);
         return p;
     }
 };

test/verify/test_convert.cpp

@@ -9,13 +9,14 @@ struct test_convert : verify_program<test_convert>
     migraphx::program create_program() const
     {
         migraphx::program p;
+        auto* mm = p.get_main_module();
         migraphx::shape sa{migraphx::shape::float_type, {8, 24}};
         migraphx::shape sb{migraphx::shape::float_type, {24, 6}};
-        auto pa = p.add_parameter("a", sa);
-        auto pb = p.add_parameter("b", sb);
-        auto ia = p.add_instruction(migraphx::op::convert{migraphx::shape::int8_type}, pa);
-        auto ib = p.add_instruction(migraphx::op::convert{migraphx::shape::int8_type}, pb);
-        p.add_instruction(migraphx::op::quant_dot{}, ia, ib);
+        auto pa = mm->add_parameter("a", sa);
+        auto pb = mm->add_parameter("b", sb);
+        auto ia = mm->add_instruction(migraphx::op::convert{migraphx::shape::int8_type}, pa);
+        auto ib = mm->add_instruction(migraphx::op::convert{migraphx::shape::int8_type}, pb);
+        mm->add_instruction(migraphx::op::quant_dot{}, ia, ib);
 
         return p;
     };

test/verify/test_cos.cpp

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

test/verify/test_cosh.cpp

@@ -9,9 +9,10 @@ struct test_cosh : verify_program<test_cosh>
     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::cosh{}, x);
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(migraphx::op::cosh{}, x);
         return p;
     }
 };

test/verify/test_deconv.cpp

@@ -9,11 +9,12 @@ struct test_deconv : verify_program<test_deconv>
     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, 1, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {1, 1, 3, 3}});
-        p.add_instruction(migraphx::op::deconvolution{}, input, weights);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {1, 1, 3, 3}});
+        mm->add_instruction(migraphx::op::deconvolution{}, input, weights);
         return p;
     }
 };

test/verify/test_deconv_1d.cpp

@@ -9,10 +9,12 @@ struct test_deconv_1d : verify_program<test_deconv_1d>
     migraphx::program create_program() const
     {
         migraphx::program p;
-        auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 3}});
+        auto* mm = p.get_main_module();
+        auto input =
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {1, 1, 3}});
-        p.add_instruction(migraphx::op::deconvolution{{0}, {1}, {1}}, input, weights);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {1, 1, 3}});
+        mm->add_instruction(migraphx::op::deconvolution{{0}, {1}, {1}}, input, weights);
         return p;
     }
 };

test/verify/test_deconv_2x3.cpp

@@ -9,11 +9,12 @@ struct test_deconv_2x3 : verify_program<test_deconv_2x3>
     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, 6, 7}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 6, 7}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {3, 4, 3, 3}});
-        p.add_instruction(migraphx::op::deconvolution{{1, 1}, {2, 3}, {1, 1}}, input, weights);
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {3, 4, 3, 3}});
+        mm->add_instruction(migraphx::op::deconvolution{{1, 1}, {2, 3}, {1, 1}}, input, weights);
         return p;
     }
 };

test/verify/test_deconv_3d.cpp

@@ -9,11 +9,12 @@ struct test_deconv_3d : verify_program<test_deconv_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, 1, 3, 3, 3}});
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 3, 3, 3}});
         auto weights =
-            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {1, 1, 3, 3, 3}});
-        p.add_instruction(
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {1, 1, 3, 3, 3}});
+        mm->add_instruction(
             migraphx::op::deconvolution{{0, 0, 0}, {1, 1, 1}, {1, 1, 1}}, input, weights);
         return p;
     }