[PATCH v3] regression_tests: skip unnecessary offload option for udp testing

[Kamil Jerabek]

gro offload does not have any impact on udp testing. In that case, there were
tested two equal combination of offloads for udp. This commit makes skip this
one unnecessary combination. It has also impact on testing time of tests.

Signed-off-by: Kamil Jerabek <kjerabek(a)redhat.com&gt;
---
 recipes/regression_tests/phase1/3_vlans.py         | 114 +++++------
 .../regression_tests/phase1/3_vlans_over_bond.py   | 114 +++++------
 recipes/regression_tests/phase1/bonding_test.py    | 106 +++++-----
 recipes/regression_tests/phase1/simple_netperf.py  |  84 +++++---
 .../phase1/virtual_bridge_2_vlans_over_bond.py     |   4 +-
 .../phase1/virtual_bridge_vlan_in_guest.py         |   4 +-
 .../phase1/virtual_bridge_vlan_in_host.py          |   4 +-
 .../regression_tests/phase2/3_vlans_over_team.py   | 110 ++++++-----
 recipes/regression_tests/phase2/team_test.py       | 220 +++++++++++----------
 ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 118 +++++------
 .../phase2/virtual_ovs_bridge_vlan_in_guest.py     | 118 +++++------
 .../phase2/virtual_ovs_bridge_vlan_in_host.py      | 118 +++++------
 12 files changed, 583 insertions(+), 531 deletions(-)

diff --git a/recipes/regression_tests/phase1/3_vlans.py
b/recipes/regression_tests/phase1/3_vlans.py
index a508697..1b68889 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -242,34 +242,35 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         srv_proc.intr()
 
@@ -302,34 +303,35 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_udp.set_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_udp.set_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         srv_proc.intr()
 
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py
b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 6c036f2..0d5afad 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -241,34 +241,35 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         srv_proc.intr()
 
@@ -301,34 +302,35 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         srv_proc.intr()
 
diff --git a/recipes/regression_tests/phase1/bonding_test.py
b/recipes/regression_tests/phase1/bonding_test.py
index 4bbf573..44c60a0 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -219,32 +219,33 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
@@ -277,32 +278,33 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
diff --git a/recipes/regression_tests/phase1/simple_netperf.py
b/recipes/regression_tests/phase1/simple_netperf.py
index 15f4f6f..9ce52c1 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -193,6 +193,7 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
+<<<<<<< HEAD
         # prepare PerfRepo result for udp
         result_udp = perf_api.new_result("udp_ipv4_id",
                                          "udp_ipv4_result",
@@ -210,6 +211,9 @@ for setting in offload_settings:
             result_udp.add_tag("multithreaded")
             result_udp.set_parameter("num_parallel", nperf_num_parallel)
 
+        if nperf_udp_size is not None:
+            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
         baseline = perf_api.get_baseline_of_result(result_udp)
         netperf_baseline_template(netperf_cli_udp, baseline)
         udp_res_data = m2.run(netperf_cli_udp,
@@ -218,6 +222,35 @@ for setting in offload_settings:
         netperf_result_template(result_udp, udp_res_data)
         result_udp.set_comment(pr_comment)
         perf_api.save_result(result_udp)
+=======
+
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter("num_parallel", nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+            udp_res_data = m2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
+>>>>>>> 28441ac... regression_tests: skip unnecessary offload option
for udp testing
         srv_proc.intr()
 
     if ipv in [ 'ipv6', 'both' ]:
@@ -247,31 +280,32 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter("num_parallel", nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-        udp_res_data = m2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("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',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter("num_parallel", nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
         srv_proc.intr()
 
 # reset offload states
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 fd421ef..a2d5399 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
@@ -297,7 +297,7 @@ for setting in offload_settings:
         result_tcp.set_comment(pr_comment)
         perf_api.save_result(result_tcp)
 
-        if enable_udp_perf is not None:
+        if enable_udp_perf is not None and ("gro", "off") not in
setting:
             # prepare PerfRepo result for udp
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
@@ -366,7 +366,7 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        if enable_udp_perf is not None:
+        if enable_udp_perf is not None and ("gro", "off") not in
setting:
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=['kernel_release',
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 62fc800..66620f7 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -234,7 +234,7 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        if enable_udp_perf is not None:
+        if enable_udp_perf is not None and ("gro", "off") not in
setting:
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=['kernel_release',
@@ -299,7 +299,7 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        if enable_udp_perf is not None:
+        if enable_udp_perf is not None and ("gro", "off") not in
setting:
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=['kernel_release',
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 ec43321..2160e0b 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -234,7 +234,7 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        if enable_udp_perf is not None:
+        if enable_udp_perf is not None and ("gro", "off") not in
setting:
             result_udp = perf_api.new_result("udp_ipv4_id",
                                              "udp_ipv4_result",
                                              hash_ignore=['kernel_release',
@@ -299,7 +299,7 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        if enable_udp_perf:
+        if enable_udp_perf and ("gro", "off") not in setting:
             result_udp = perf_api.new_result("udp_ipv6_id",
                                              "udp_ipv6_result",
                                              hash_ignore=['kernel_release',
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py
b/recipes/regression_tests/phase2/3_vlans_over_team.py
index a157c45..5936347 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -242,33 +242,34 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         srv_proc.intr()
 
@@ -302,33 +303,34 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
-        result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv6_id",
+                                             "udp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server_on_vlan', vlans[0])
+            result_udp.set_parameter('netperf_client_on_vlan', vlans[0])
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         srv_proc.intr()
 
diff --git a/recipes/regression_tests/phase2/team_test.py
b/recipes/regression_tests/phase2/team_test.py
index fc6ed08..014194d 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -221,33 +221,34 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server', "testmachine1")
-        result_udp.set_parameter('netperf_client', "testmachine2")
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server', "testmachine1")
+            result_udp.set_parameter('netperf_client', "testmachine2")
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
     if ipv in [ 'ipv6', 'both' ]:
@@ -282,33 +283,34 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server', "testmachine1")
-        result_udp.set_parameter('netperf_client', "testmachine2")
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = m2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration + nperf_reserve)*5)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv6_id",
+                                             "udp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server', "testmachine1")
+            result_udp.set_parameter('netperf_client', "testmachine2")
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration + nperf_reserve)*5)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
@@ -388,33 +390,34 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_ipv4_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server', "testmachine2")
-        result_udp.set_parameter('netperf_client', "testmachine1")
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = m1.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server', "testmachine2")
+            result_udp.set_parameter('netperf_client', "testmachine1")
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = m1.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
     if ipv in [ 'ipv6', 'both' ]:
@@ -449,33 +452,34 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_ipv6_result",
-                                         hash_ignore=[
-                                             'kernel_release',
-                                             'redhat_release'])
-        for offload in setting:
-            result_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.set_parameter('netperf_server', "testmachine2")
-        result_udp.set_parameter('netperf_client', "testmachine1")
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = m1.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv6_id",
+                                             "udp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            for offload in setting:
+                result_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.set_parameter('netperf_server', "testmachine2")
+            result_udp.set_parameter('netperf_client', "testmachine1")
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = m1.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
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 affc6f5..897b173 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
@@ -277,35 +277,36 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_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_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = g3.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_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_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = g3.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
     if ipv in [ 'ipv6', 'both' ]:
@@ -345,35 +346,36 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_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_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = g3.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv6_id",
+                                             "udp_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_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = g3.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
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 5b7ca94..f084f37 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
@@ -222,35 +222,36 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_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_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = h2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_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_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = h2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
     if ipv in [ 'ipv6', 'both' ]:
@@ -287,35 +288,36 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_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_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = h2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv6_id",
+                                             "udp_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_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = h2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
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 6acb1b1..31e57af 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
@@ -221,35 +221,36 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp
-        result_udp = perf_api.new_result("udp_ipv4_id",
-                                         "udp_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_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp, baseline)
-
-        udp_res_data = h2.run(netperf_cli_udp,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_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_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp, baseline)
+
+            udp_res_data = h2.run(netperf_cli_udp,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
@@ -287,35 +288,36 @@ for setting in offload_settings:
         perf_api.save_result(result_tcp)
 
         # prepare PerfRepo result for udp ipv6
-        result_udp = perf_api.new_result("udp_ipv6_id",
-                                         "udp_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_udp.set_parameter(offload[0], offload[1])
-
-        if nperf_udp_size is not None:
-            result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
-
-        result_udp.add_tag(product_name)
-        if nperf_mode == "multi":
-            result_udp.add_tag("multithreaded")
-            result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
-        baseline = perf_api.get_baseline_of_result(result_udp)
-        netperf_baseline_template(netperf_cli_udp6, baseline)
-
-        udp_res_data = h2.run(netperf_cli_udp6,
-                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
-        netperf_result_template(result_udp, udp_res_data)
-        result_udp.set_comment(pr_comment)
-        perf_api.save_result(result_udp)
+        if ("gro", "off") not in setting:
+            result_udp = perf_api.new_result("udp_ipv6_id",
+                                             "udp_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_udp.set_parameter(offload[0], offload[1])
+
+            if nperf_udp_size is not None:
+                result_udp.set_parameter("nperf_udp_size", nperf_udp_size)
+
+            result_udp.add_tag(product_name)
+            if nperf_mode == "multi":
+                result_udp.add_tag("multithreaded")
+                result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
+
+            udp_res_data = h2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_udp, udp_res_data)
+            result_udp.set_comment(pr_comment)
+            perf_api.save_result(result_udp)
 
         server_proc.intr()
 
-- 
2.5.5