[PATCH] recipes: add nperf_protocols alias to select netperf tests

[Jan Tluka]

All phase1 and phase2 tests now take optional alias nperf_protocols that
can be used to limit which netperf tests to run.

For example, if set to 'tcp udp', only TCP_STREAM and UDP_STREAM are run,
SCTP_STREAM will be skipped. The default value is all protocol tests, i.e.
TCP, UDP and SCTP.

This patch also removes the 'enable_udp_perf' alias from virtual bridge tests
since the new alias can be used in similar manner.

Signed-off-by: Jan Tluka <jtluka(a)redhat.com&gt;
---
 recipes/regression_tests/phase1/3_vlans.py         | 109 +++++----
 recipes/regression_tests/phase1/3_vlans.xml        |   1 +
 .../phase1/3_vlans_over_active_backup_bond.xml     |   1 +
 .../regression_tests/phase1/3_vlans_over_bond.py   | 109 +++++----
 .../regression_tests/phase1/active_backup_bond.xml |   1 +
 .../phase1/active_backup_double_bond.xml           |   1 +
 recipes/regression_tests/phase1/bonding_test.py    | 101 ++++----
 recipes/regression_tests/phase1/simple_netperf.py  | 121 +++++-----
 recipes/regression_tests/phase1/simple_netperf.xml |   1 +
 ...tual_bridge_2_vlans_over_active_backup_bond.xml |   1 +
 .../phase1/virtual_bridge_2_vlans_over_bond.py     | 140 +++++------
 .../phase1/virtual_bridge_vlan_in_guest.py         | 142 +++++------
 .../phase1/virtual_bridge_vlan_in_guest.xml        |   1 +
 .../phase1/virtual_bridge_vlan_in_host.py          | 142 +++++------
 .../phase1/virtual_bridge_vlan_in_host.xml         |   1 +
 .../phase2/3_vlans_over_active_backup_team.xml     |   1 +
 .../regression_tests/phase2/3_vlans_over_team.py   | 137 ++++++-----
 .../phase2/active_backup_double_team.xml           |   1 +
 .../regression_tests/phase2/active_backup_team.xml |   1 +
 .../active_backup_team_vs_active_backup_bond.xml   |   1 +
 recipes/regression_tests/phase2/team_test.py       | 268 +++++++++++----------
 ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 146 +++++------
 ..._ovs_bridge_2_vlans_over_active_backup_bond.xml |   1 +
 .../phase2/virtual_ovs_bridge_vlan_in_guest.py     | 146 +++++------
 .../phase2/virtual_ovs_bridge_vlan_in_guest.xml    |   1 +
 .../phase2/virtual_ovs_bridge_vlan_in_host.py      | 145 +++++------
 .../phase2/virtual_ovs_bridge_vlan_in_host.xml     |   1 +
 27 files changed, 899 insertions(+), 822 deletions(-)

diff --git a/recipes/regression_tests/phase1/3_vlans.py
b/recipes/regression_tests/phase1/3_vlans.py
index 6e6611f..442dbdc 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -267,36 +268,37 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
 
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
 
-        result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+            result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
 
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
 
-        tcp_res_data = m2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+            tcp_res_data = m2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
 
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
 
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
 
-        result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_tcp.set_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+            result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_tcp.set_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
 
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-        tcp_res_data = m2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+            tcp_res_data = m2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
 
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/3_vlans.xml
b/recipes/regression_tests/phase1/3_vlans.xml
index 3c56aad..fdc681f 100644
--- a/recipes/regression_tests/phase1/3_vlans.xml
+++ b/recipes/regression_tests/phase1/3_vlans.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file" value="3_vlans.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
         <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
index 431202b..50a984e 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="3_vlans_over_active_backup_bond.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
         <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py
b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 2e0685e..8fc8dd6 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -267,36 +268,37 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
 
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
 
-        result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+            result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
 
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
 
-        tcp_res_data = m2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+            tcp_res_data = m2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
 
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
 
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
 
-        result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+            result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
 
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-        tcp_res_data = m2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+            tcp_res_data = m2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
 
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/active_backup_bond.xml
b/recipes/regression_tests/phase1/active_backup_bond.xml
index ce2e610..ca65f54 100644
--- a/recipes/regression_tests/phase1/active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/active_backup_bond.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="active_backup_bond.mapping" />
         <alias name="net" value="192.168.0"/>
         <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/active_backup_double_bond.xml
b/recipes/regression_tests/phase1/active_backup_double_bond.xml
index 5154504..e769ffb 100644
--- a/recipes/regression_tests/phase1/active_backup_double_bond.xml
+++ b/recipes/regression_tests/phase1/active_backup_double_bond.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="active_backup_double_bond.mapping" />
         <alias name="net" value="192.168.0"/>
         <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/bonding_test.py
b/recipes/regression_tests/phase1/bonding_test.py
index 8b1dfc5..e08a4e5 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -256,34 +257,35 @@ for setting in offload_settings:
         server_proc = m1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
 
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
 
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
 
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
 
-        tcp_res_data = m2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+            tcp_res_data = m2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
 
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
@@ -312,8 +314,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -344,34 +347,35 @@ for setting in offload_settings:
         server_proc = m1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
 
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
 
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
 
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-        tcp_res_data = m2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+            tcp_res_data = m2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
 
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
@@ -400,8 +404,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.py
b/recipes/regression_tests/phase1/simple_netperf.py
index 272b57d..9ef7cf6 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -40,6 +40,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -220,33 +221,34 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter("num_parallel", nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-        tcp_res_data = m2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter("num_parallel", nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+            tcp_res_data = m2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
@@ -274,8 +276,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -304,33 +307,34 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter("num_parallel", nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-        tcp_res_data = m2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter("num_parallel", nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+            tcp_res_data = m2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
@@ -358,8 +362,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.xml
b/recipes/regression_tests/phase1/simple_netperf.xml
index a202852..cd90233 100644
--- a/recipes/regression_tests/phase1/simple_netperf.xml
+++ b/recipes/regression_tests/phase1/simple_netperf.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2" />
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file" value="simple_netperf.mapping"
/>
         <alias name="net" value="192.168.101" />
         <alias name="driver" value="ixgbe" />
diff --git
a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
index 9a2b3f4..a0d96e6 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
@@ -9,6 +9,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mtu" value="1500" />
         <alias name="mapping_file"
value="virtual_bridge_2_vlans_over_active_backup_bond.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
index ae8baf9..c8715e8 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
@@ -46,6 +46,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -61,7 +62,6 @@ else:
 pr_comment = generate_perfrepo_comment([h1, g1, g2, h2, g3, g4], pr_user_comment)
 
 mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
 
 h1_nic1 = h1.get_interface("nic1")
 h1_nic2 = h1.get_interface("nic2")
@@ -326,37 +326,38 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=['kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = g3.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        if enable_udp_perf is not None and ("gro", "off") not in
setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = g3.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
             # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
@@ -388,8 +389,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -423,38 +425,39 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=['kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = g3.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if enable_udp_perf is not None and ("gro", "off") not in
setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = g3.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=['kernel_release',
@@ -485,8 +488,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
index f769086..0cfdf23 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -57,7 +58,6 @@ else:
 pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
 
 mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
 
 h2_vlan10 = h2.get_interface("vlan10")
 g1_vlan10 = g1.get_interface("vlan10")
@@ -258,38 +258,39 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=['kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if enable_udp_perf is not None and ("gro", "off") not in
setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=['kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if enable_udp_perf is not None and ("gro", "off") not in
setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
index dd33be1..22aedf4 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
@@ -9,6 +9,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mtu" value="1500" />
         <alias name="mapping_file"
value="virtual_bridge_vlan_in_guest.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
index 9607132..9cebece 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -57,7 +58,6 @@ else:
 pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
 
 mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
 
 h2_vlan10 = h2.get_interface("vlan10")
 g1_guestnic= g1.get_interface("guestnic")
@@ -258,38 +258,39 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=['kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if enable_udp_perf is not None and ("gro", "off") not in
setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=['kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if enable_udp_perf and ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
index 382d9c6..5a71d40 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
@@ -9,6 +9,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mtu" value="1500" />
         <alias name="mapping_file"
value="virtual_bridge_vlan_in_host.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
index 683675f..8e778f2 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
+++ b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="3_vlans_over_active_backup_team.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
         <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py
b/recipes/regression_tests/phase2/3_vlans_over_team.py
index 4824db7..0c58fdf 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -267,37 +268,38 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = m2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = m2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=[
@@ -327,8 +329,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -359,37 +362,38 @@ for setting in offload_settings:
         srv_proc = m1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = m2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = m2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=[
@@ -419,8 +423,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase2/active_backup_double_team.xml
b/recipes/regression_tests/phase2/active_backup_double_team.xml
index 420992f..b4be042 100644
--- a/recipes/regression_tests/phase2/active_backup_double_team.xml
+++ b/recipes/regression_tests/phase2/active_backup_double_team.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="active_backup_double_team.mapping" />
         <alias name="net" value="192.168.0"/>
         <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team.xml
b/recipes/regression_tests/phase2/active_backup_team.xml
index 7a1f059..7b332a0 100644
--- a/recipes/regression_tests/phase2/active_backup_team.xml
+++ b/recipes/regression_tests/phase2/active_backup_team.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="active_backup_team.mapping" />
         <alias name="net" value="192.168.0"/>
         <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
index 37e0d02..fca487f 100644
--- a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
+++ b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
@@ -10,6 +10,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="active_backup_team_vs_active_backup_bond.mapping" />
         <alias name="net" value="192.168.0"/>
         <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/team_test.py
b/recipes/regression_tests/phase2/team_test.py
index 25a2823..e953ac0 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -40,6 +40,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -255,37 +256,38 @@ for setting in offload_settings:
         server_proc = m1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.set_parameter('netperf_server', "testmachine1")
-        result_tcp.set_parameter('netperf_client', "testmachine2")
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = m2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.set_parameter('netperf_server', "testmachine1")
+            result_tcp.set_parameter('netperf_client', "testmachine2")
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = m2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=[
@@ -316,8 +318,9 @@ for setting in offload_settings:
 
         # prepare PerfRepo result for sctp
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -349,37 +352,38 @@ for setting in offload_settings:
         server_proc = m1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.set_parameter('netperf_server', "testmachine1")
-        result_tcp.set_parameter('netperf_client', "testmachine2")
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = m2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration + nperf_reserve)*5)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.set_parameter('netperf_server', "testmachine1")
+            result_tcp.set_parameter('netperf_client', "testmachine2")
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = m2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration + nperf_reserve)*5)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=[
@@ -494,37 +498,38 @@ for setting in offload_settings:
         server_proc = m2.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.set_parameter('netperf_server', "testmachine2")
-        result_tcp.set_parameter('netperf_client', "testmachine1")
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = m1.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.set_parameter('netperf_server', "testmachine2")
+            result_tcp.set_parameter('netperf_client', "testmachine1")
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = m1.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=[
@@ -555,8 +560,9 @@ for setting in offload_settings:
 
         # prepare PerfRepo result for sctp
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -588,37 +594,38 @@ for setting in offload_settings:
         server_proc = m2.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.set_parameter('netperf_server', "testmachine2")
-        result_tcp.set_parameter('netperf_client', "testmachine1")
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = m1.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.set_parameter('netperf_server', "testmachine2")
+            result_tcp.set_parameter('netperf_client', "testmachine1")
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = m1.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=[
@@ -649,8 +656,9 @@ for setting in offload_settings:
 
         # prepare PerfRepo result for sctp
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git
a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
index ccabb5b..0a5f6c3 100644
---
a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
+++
b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
@@ -47,6 +47,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -324,39 +325,40 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = g3.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = g3.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=[
@@ -388,8 +390,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -413,6 +416,7 @@ for setting in offload_settings:
             perf_api.save_result(result_sctp)
 
         server_proc.intr()
+
     if ipv in [ 'ipv6', 'both' ]:
         g1.run(ping_mod6)
         g4.run(ping_mod62)
@@ -422,39 +426,40 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = g3.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = g3.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=[
@@ -486,8 +491,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git
a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
index 01c4291..8991be0 100644
---
a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
+++
b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
@@ -10,6 +10,7 @@
         <alias name="mtu" value="1500" />
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mapping_file"
value="virtual_ovs_bridge_2_vlans_over_active_backup_bond.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
         <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
index 8274601..dede110 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
@@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -257,39 +258,40 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=[
@@ -321,8 +323,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -346,45 +349,47 @@ for setting in offload_settings:
             perf_api.save_result(result_sctp)
 
         server_proc.intr()
+
     if ipv in [ 'ipv6', 'both' ]:
         g1.run(ping_mod6)
 
         server_proc = g1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=[
@@ -416,8 +421,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
index 786b9d3..739450e 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
@@ -9,6 +9,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mtu" value="1500" />
         <alias name="mapping_file"
value="virtual_ovs_bridge_vlan_in_guest.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
index f0fd8c1..6b07372 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
@@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev")
 nperf_msg_size = ctl.get_alias("nperf_msg_size")
 pr_user_comment = ctl.get_alias("perfrepo_comment")
 offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
 
 sctp_default_msg_size = "16K"
 
@@ -255,39 +256,40 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp
-        result_tcp = perf_api.new_result("tcp_ipv4_id",
-                                         "tcp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=[
@@ -319,8 +321,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv4_id",
                                               "sctp_ipv4_result",
                                               hash_ignore=[
@@ -351,39 +354,40 @@ for setting in offload_settings:
         server_proc = g1.run(netperf_srv6, bg=True)
         ctl.wait(2)
 
-        # prepare PerfRepo result for tcp ipv6
-        result_tcp = perf_api.new_result("tcp_ipv6_id",
-                                         "tcp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release',
-                                             r'guest\d+\.hostname',
-                                             r'guest\d+\..*hwaddr',
-                                             r'host\d+\..*tap\d*\.hwaddr',
-                                             r'host\d+\..*tap\d*\.devname'])
-        for offload in setting:
-            result_tcp.set_parameter(offload[0], offload[1])
-
-        if nperf_msg_size is not None:
-            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
-        result_tcp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_tcp.add_tag("multithreaded")
-            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_tcp)
-        netperf_baseline_template(netperf_cli_tcp6, baseline)
-
-        tcp_res_data = h2.run(netperf_cli_tcp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_tcp, tcp_res_data)
-        result_tcp.set_comment(pr_comment)
-        perf_api.save_result(result_tcp)
-
-        # prepare PerfRepo result for udp ipv6
-        if ("gro", "off") not in setting:
+        if nperf_protocols.find("tcp") > -1:
+            # prepare PerfRepo result for tcp ipv6
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr',
+                                                 r'host\d+\..*tap\d*\.hwaddr',
+                                                 r'host\d+\..*tap\d*\.devname'])
+            for offload in setting:
+                result_tcp.set_parameter(offload[0], offload[1])
+
+            if nperf_msg_size is not None:
+                result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+            result_tcp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_tcp.add_tag("multithreaded")
+                result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+            tcp_res_data = h2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            result_tcp.set_comment(pr_comment)
+            perf_api.save_result(result_tcp)
+
+        if nperf_protocols.find("udp") > -1 and ("gro",
"off") not in setting:
+            # prepare PerfRepo result for udp ipv6
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=[
@@ -415,8 +419,9 @@ for setting in offload_settings:
             perf_api.save_result(result_udp)
 
         # for SCTP only gso offload on/off
-        if (len({val for val in setting if val[1] == 'off'}) == 0 or
-           ('gso', 'off') in setting):
+        if (nperf_protocols.find("sctp") > -1 and
+              (len({val for val in setting if val[1] == 'off'}) == 0 or
+               ('gso', 'off') in setting)):
             result_sctp = perf_api.new_result("sctp_ipv6_id",
                                               "sctp_ipv6_result",
                                               hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
index 5f8b9e5..8c1de53 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
@@ -9,6 +9,7 @@
         <alias name="nperf_num_parallel" value="2"/>
         <alias name="nperf_debug" value="0"/>
         <alias name="nperf_max_dev" value="20%"/>
+        <alias name="nperf_protocols" value="tcp udp sctp"/>
         <alias name="mtu" value="1500" />
         <alias name="mapping_file"
value="virtual_ovs_bridge_vlan_in_host.mapping" />
         <alias name="vlan10_net" value="192.168.10"/>
-- 
2.7.4